Inspiration
A lot of people, who learn programming follow that path of block based programming tools to actual programming languages (example: scratch to python). There's nothing wrong with that, but because block based programming is visual and comparatively simpler, students often face difficulties in there transition from block based programming to written programming. They are usually already confused by new things such as IDE, interpreter etc., at that time, the extra difficulties caused by understanding complex syntaxes and managing errors just increases there confusion. It is not a made up problem, but lot students face this, including me when I was learning to code. So the motivation for this project is nothing but the natural desire to find a solution of a problem which has also at a time made my life harder.
What it does
Beyond Blocks is a Python library designed to act as a bridge between block based programming and written programming(especially python). Many python functions(and other languages as well), which has the same concept that the student has already learnt in tools like scratch, gets students confused because of the complicated written syntax. Beyond Blocks solves this problem, this library uses lot simpler and similar to block based programming syntaxes, so that the student doesn't get confused by complex syntaxes and can focus of mastering the concept and logic. This library also has a unique function named 'explain()', that function takes any code block as input, and uses AI to explain the code to the student. Similarly there is one more AI based internal function for error handling. What happens is when someone is coding for the first time in there life, a small mistake (which can be very common), can create significant friction in the students mind. Therefore this function doesn't let the error reach student's terminal, instead what it does is, instead of a throwing a scary error, explains the student's mistake to them, and gives them a clue to solve the error, so that they don't get demotivated from mistakes, but learn from it. The aim is not to spoon-feed students and stop them from learning to code, but it is to, in the initial stages, keep them away from the complicated syntaxes and scary errors, so that they can focus on learning the logic, and the art of writing programs. And once they get comfortable with writing and understanding code, they can move to the actual syntaxes and rules of different languages.
How we built it
Beyond Blocks was built as a normal, importable Python package rather than as a separate programming environment. This was an important design decision because the learner should still be writing actual Python. The core library contains simple functions such as ask(), repeat(), forever(), wait(), say(), and random_number(). Where Python already provides a simple and beginner-friendly solution, such as print(), we intentionally did not create an unnecessary replacement. The AI features were built using the Groq API. explain() sends the learner's code to the AI with instructions to explain it in simple language rather than simply generating a solution. The runtime error feature uses Python's exception-hook system to intercept uncaught errors and provide a beginner-friendly explanation. We used pyttsx3 for text-to-speech functionality and python-dotenv for local environment-variable configuration. We also created a development-container configuration for GitHub Codespaces so that the project could be run in a reproducible browser-based environment. API credentials are supplied through environment variables rather than being stored in the repository. Testing was done in stages, including normal function testing, edge-case testing, package installation testing, testing from a downloaded copy of the repository, and testing in a fresh Codespace.
Challenges we ran into
One of the biggest challenges was making the project work across different environments rather than only on the development machine. The text-to-speech feature was particularly challenging because pyttsx3 depends on operating-system-level audio components. Getting the required Linux dependencies into Codespaces was only part of the problem; a remote Codespace may still not have an audio output device. This taught us that a Python package can be completely correct while one of its environment-dependent features behaves differently on another machine. Another challenge was integrating the AI features without exposing API credentials. The API key had to be configured through environment variables and Codespaces secrets rather than being included in the source code. We also discovered that testing only on our own computer was not enough. A package that works locally can still fail because of differences in Python environments, system dependencies, or configuration.
Accomplishments that we're proud of
We are particularly proud that Beyond Blocks became a real Python package rather than just a demonstration script. The core functions are intentionally small and focused, but together they create a bridge between concepts students may already understand from block-based programming and the syntax of real Python. We are also proud of integrating AI in a way that supports learning rather than simply generating answers. Both the code explanation feature and the error explanation feature are designed to help students understand what is happening and think about the solution themselves. Finally, we successfully packaged the project so that it could be installed and tested in a fresh environment, including GitHub Codespaces.
What we learned
One of the biggest things we learned was that writing the code is only one part of building a usable software project. Packaging, dependency management, environment variables, system-level dependencies, documentation, testing, and deployment all introduced problems that would not have appeared if we had only run the code on our own computer. We also learned the importance of testing outside the original development environment. Testing the project on another computer and in a fresh Codespace exposed environment-specific issues that normal function tests could not find. Most importantly, we learned that beginner-friendly software is not simply about making everything easier. It is about removing the right sources of friction while still allowing the learner to develop the underlying skill.
What's next for Beyond Blocks
The current version focuses on the core bridge between block-based concepts and Python. Future versions could expand the library with more beginner-friendly abstractions, improve the AI explanations, provide better handling of different execution environments, and add more learning-oriented features. A longer-term goal is to make the transition gradual: start with familiar concepts and simple Python functions, then progressively encourage learners to use standard Python syntax as they become more confident.
Log in or sign up for Devpost to join the conversation.