Thadus CodeLabs. Learn computer science, not just code.
An offline-first learning environment where students use executable pseudocode to understand algorithms, data, AI, systems and software, without getting stuck on programming syntax.
- Offline-first: no internet needed
- Executable pseudocode: plain-English programming
- Concept-first: syntax can come later
- Free for NGOs and charities
It started with a question: why is this so hard to get started?
Travelling across Asia, through classrooms, community centres and conversations with young people who were sharp, motivated and completely locked out of computer science, we kept seeing the same pattern. The barrier wasn't aptitude. It was access: no reliable internet, underpowered devices, and learning environments that required a student to master complicated programming syntax before they could explore a single concept.
That created a clear problem to solve. In 2025 we founded Thadus Group and built Thadus CodeLabs: an offline-first computer science learning environment built around one central idea. Beginners should be able to understand how software works before they have to master how to write it.
One environment. Twelve ways to understand technology.
Thadus CodeLabs is a desktop learning environment built around one idea: beginners should be able to explore computer science before they have to master a programming language. Students open it and start reasoning computationally from day one.
Twelve structured courses take students from computational thinking through algorithms, data, games, applications, cybersecurity, AI and machine learning foundations, all within one consistent environment.
- Works in areas with zero internet connectivity
- Runs on low-spec hardware: no powerful devices needed
- Zero setup for students: open and code immediately
- Collects zero data: full privacy by default
// Create and move an object
ball = new object
ball moveRight(15)
ball moveUp(10)
// A simple condition
num score = 8
if (score > 6)
print levelclear
else
print retry
end ifStudents write almost plain-English instructions and immediately see how their logic affects the system. The objective isn't to make programming easier. It's to make computer science understandable.
Think in systems. Write in plain English.
Thadus deliberately minimises programming syntax so students can concentrate on what a program is doing, rather than how a particular language requires it to be written.
Concept first
Students focus on algorithms, logic, data, systems and computational thinking, not on the bookkeeping rules of a particular programming language.
Executable pseudocode
Instructions are written in simple, readable commands that behave like real programs. Students can express a process almost like writing it in plain English, and see it actually execute.
Transferable understanding
Students build mental models they can apply to any programming language, or AI-assisted development tool, from a position of understanding.
Accessible in two ways
Most educational platforms solve one access problem. Thadus solves two at once.
Digitally accessible
Runs entirely offline on low-spec hardware. No internet, no accounts, no installation headaches. Computer science education becomes possible where connectivity cannot be assumed.
Pedagogically accessible
Uses executable pseudocode so students focus on understanding concepts instead of fighting programming syntax. The cognitive barrier comes down alongside the digital one.
A computer science education built around concepts
The curriculum doesn't start with “learn a programming language.” It starts with how computers think, how systems work, and how technology solves problems. Twelve courses, two per month, built on the CSTA K–12 Computer Science Standards for Years 5–9.
Computational Thinking
Sequencing, decomposition, loops, conditions, and functions through logic-based route challenges.
Algorithms and Sequencing
Arrays, search techniques, and foundational sorting logic.
Data Science
Collecting, transforming, and visualising data: totals, averages, trends, and outliers.
Game Development
Scene design, sprites, controls, and win/lose logic, ending in a playable mini game.
App Design and Interface Logic
Interface structure, components, and screen linking in a working mini app.
App Development and User Flows
Multi-screen navigation, onboarding flows, menus, and settings.
Simulation and Systems Modelling
Entities, metrics, and rules to model real-world systems, trade-offs and bottlenecks.
Data Systems and Decision Dashboards
Dashboards, alerts, and charts for data-informed decisions.
Cybersecurity and Secure Systems
Password logic, access control, and permissions in secure portal design.
Intelligent Systems and AI Logic
Students build rule-based systems and explore how machines classify inputs, make decisions and generate responses. No black box: students learn what is happening underneath.
Machine Learning Foundations
Students explore features, labelled data, classification and prediction quality, building an intuitive understanding of how machine-learning systems work before they ever see a framework.
Product Engineering Capstone
Full product planning and build, culminating in a final showcase project.
Explore each course
Each one builds a concept students can use, regardless of which language or tool they eventually work with.
Sequencing, decomposition, loops, and decisions.
Students work through route-planning and logic challenges that build precise algorithmic thinking. By the end they can write loops, conditions and reusable functions, the patterns that appear in every type of software.
- Rewrite a Route
- Build the Rover Path
- Loop a Patrol
- Score Gate
- Computational Thinking Final Build
Arrays, search techniques, and sorting logic.
Students build arrays from real data tables, then write algorithms to search through and sort them. The focus is on understanding why an algorithm works, not just that it does. A foundation for data, AI and systems work in later courses.
- Build an Array from a Table
- Linear Search for a Shelf Number
- Bubble Sort First Pass
- Count Large Values
- Algorithms Final Build
Collecting, transforming, and making sense of data.
Students load real datasets, calculate totals and averages, plot trends and identify outliers. They practise asking "what does the data actually say?", the core skill behind data analysis, business intelligence and machine learning alike.
- Attendance Table Investigation
- Bus Passenger High and Low
- Detect an Outlier
- Plot a Complex Trend
- Data Science Final Investigation
Scenes, sprites, controls, and win/lose logic.
Students plan, build and publish a playable mini game. Game development is a powerful context for learning conditions, iteration and state, because students immediately see how their logic changes what happens on screen.
- Choose Your Game Path
- Add Your Player
- Add Real Player Controls
- Build Touch Rules
- Final Game Build
Screens, components, and how interfaces are structured.
Students design and build a multi-screen mini app, starting with a login screen and linking it to a home screen. The focus is on understanding how interface structure and user flow are designed before they are coded. Directly transferable to any app development environment.
- Plan the App Purpose
- Create a Login Screen
- Build a Home Screen
- Link Screens Together
- Final Mini App Build
Onboarding, navigation, settings, and usability.
Students build a complete multi-screen product with onboarding, navigation and settings. They learn to think from the user's perspective: why a flow works, where it breaks, and how to improve it. This is product thinking, not just coding.
- Describe the User Journey
- Build an Onboarding Screen
- Build a Menu Screen
- Link the Main Navigation
- Final Multi-Screen App Project
Rules, entities, and how systems behave over time.
Students model real-world systems: queues, traffic cycles and populations. They observe how rules and variables interact to produce emergent behaviour. Small rule changes, large outcomes. This is the course where systems thinking becomes concrete.
- Create a Queue Model
- Add a Traffic Light Cycle
- Build a Population Counter
- Detect a Bottleneck
- Final Real-World Simulation Build
Pipelines, charts, thresholds, and rule-based alerts.
Students build decision dashboards from scratch: loading datasets, plotting attendance and performance trends, detecting outliers and creating alerts that fire when a threshold is crossed. The full pipeline from raw data to a decision.
- Build a Dataset from a Table
- Plot the Attendance Trend
- Detect an Outlier
- Create a Rule-Based Alert
- Final Data Dashboard Project
Authentication, access control, and how systems fail.
Students build a secure school portal, writing password rules, adding role-based access permissions, detecting suspicious input and debugging insecure code. Security is a great lens for understanding how systems are designed and where they break down.
- Build a Password Rule Checker
- Add Limited Access Rules
- Detect Suspicious Input
- Build a Secure School Portal Mockup
- Final Secure System Build
Rule-based decisions, classification, and building an AI assistant.
Students build an AI assistant from scratch using rules and classifiers, then test it, find its biases, and improve it. No black box. Students see exactly why the system responds the way it does, which means they understand what "AI" is actually doing at the logic level.
- Build a Rule-Based Recommender
- Classify Inputs into Categories
- Improve the Responses
- Detect Bias or Poor Rules
- Final Intelligent Assistant Build
Labelled data, features, classifiers, and prediction.
Students label datasets, choose features, build a simple classifier and then test it on data the model has never seen. The course is deliberately non-framework: students understand what a model is doing before they ever see one pre-built. That's the knowledge that transfers to any ML context.
- Label a Dataset
- Build a Rule-Based Classifier First
- Test the Model on New Data
- Reflect on Bias and Data Quality
- Final Intro ML Project
Planning, prototyping, testing, and shipping something real.
Students choose a track (App, Game, Simulation, Dashboard, Cyber, or AI Lab) and build a complete product end to end. This is the course where everything comes together: product thinking, iteration, testing, and delivering something a real person could use.
- Choose a Product Track and Problem
- Start Building the First Version
- Improve Interaction and Feedback
- Test and Debug the Product
- Submit the Full Product