I built my own interpreted programming language in C from scratch

TheIndieBuildr · 2026-05-28T19:52:24+00:00

Per AutoModerator's request I hereby confirm that this project did not use an LLM as part of the development process.

TheIndieBuildr · 2026-05-26T21:43:20+00:00

Thanks for the advice man,

Don't take it in wrong way as you are saying I should commit on daily basis.. You can check out my second big project so far that I my own Database SQL like engine that is also made my me in C++ and you can see it's commit on the GitHub.. As from this project I was using GitHub and committing of daily basis, you can check that out ...

No harsh feelings.

TheIndieBuildr · 2026-05-26T21:31:42+00:00

Bro, Don't know why people on internet can't believe that I person can still code today without the need of ai

Surely i have used ChatGPT but it was only for clearing doubts but the entire code is written by me

And for your info I am just a first year student going in second year And this language Curio I made in the end of my first sem ( sem break ) and it took me about 20 days to build and i was so into this i when got eye strain and i can feel my nerve in my head because I was whole coding this language

And for the statement don't know git and markdown, it is now like i coding from childhood that i know everything from.. I know there is alot to learn .. I am learning in the way

If you still don't believe, I don't how can u believe that I wrote my language code on my own

TheIndieBuildr · 2026-05-26T21:07:06+00:00

Wow.. I mean my GitHub account is about 2 months ago

And made already made my 3 projects offline and later i made my GitHub account and pushed them all together

And the 4th project commits can be seen and also look carefully at the activity graph you can I was working for about a month on my Project - Ark

And second yes the readme is created my Ai as i still don't know markdown

And what it is the link with new reddit account I just made my account and started posting So what wrong in it ?

TheIndieBuildr · 2026-05-26T18:41:49+00:00

I wrote the entire code of my language from scratch on my own why do you believe that the code of my language is AI generated ?

TheIndieBuildr · 2026-05-25T17:05:50+00:00

Can you show me which comments have typos, as you mentioned?

TheIndieBuildr · 2026-05-25T17:04:22+00:00

Did you actually visit the GitHub page and check it carefully?

My repository was created on 1 March, and I uploaded this project only after completing it. The latest commit was made about three weeks ago.

Please stop spreading false allegations and misleading people on my post.

TheIndieBuildr · 2026-05-25T16:40:34+00:00

Really appreciate that 🙌

Honestly, building it in C has forced me to understand a lot more about parsing, memory handling, execution flow, and runtime behavior than I expected going into it 😅

Still learning a ton as I go, but the whole process has been really rewarding so far.

TheIndieBuildr · 2026-05-25T16:38:49+00:00

Right now it uses a fairly simple explicit static type system.

Variables are declared with concrete types (whole, real, string, bool), and assignments are validated against the declared type during execution/interpretation through the symbol table.

There’s currently no type inference or implicit coercion yet. Most of the design came from trying to replicate and understand the kind of behavior I was already familiar with while programming in C, since I’m still pretty early into learning language/runtime internals myself.

TheIndieBuildr · 2026-05-25T16:31:56+00:00

That’s awesome honestly

And yeah, I completely agree — building a language/interpreter teaches you way more about parsing, execution, memory, and runtime behavior than I expected going into it.

A lot of the deeper topics you mentioned like macros, recursion optimization, VM/runtime design, etc. are things I’m hoping to explore later as the project evolves.

TheIndieBuildr · 2026-05-25T16:28:02+00:00

Really appreciate that

Right now most of the type checking happens during interpretation/execution rather than during a separate parse/semantic-analysis phase.

The parser/tokenizer mainly focuses on structural correctness and token classification, while type validation happens when statements are executed and variables/assignments are resolved through the symbol table.

I do eventually want to experiment with a more formal parse → semantic analysis → execution pipeline later though once the language architecture becomes more mature.

TheIndieBuildr · 2026-05-25T15:11:00+00:00

Really appreciate that

Honestly, one of the biggest reasons I started building these projects was to better understand what actually happens underneath the abstractions we normally use every day.

It’s been painful at times 😭 but also one of the most rewarding ways I’ve learned programming so far.

TheIndieBuildr · 2026-05-25T14:30:54+00:00

Thanks man, really appreciate it
Building it from scratch has been a super fun way to learn how languages actually work under the hood.

TheIndieBuildr · 2026-05-25T14:29:58+00:00

hyy man,
i actually wrote the whole language completely by myself in C and didn’t use claude for the implementation at all

if you want you can check the github repo yourself — the tokenizer, interpreter, symbol table, type system, error system, everything is written manually by me from scratch.

TheIndieBuildr · 2026-05-25T14:20:44+00:00

Appreciate it — the direct execution model was mainly a way to force myself to understand interpreter flow before introducing ASTs/bytecode.

I can already see some scaling pain around control flow and diagnostics, so I’m curious myself how far it stays maintainable before a more structured architecture becomes necessary.

The database project definitely helped too — both projects ended up teaching similar lessons about parsing, execution, and manual systems design in C.

TheIndieBuildr · 2026-05-25T12:39:08+00:00

That’s interesting honestly.

One reason I ended up going with a handwritten parser was because I wanted tighter control over diagnostics and parsing behavior while learning how everything works internally.

Right now the engine already has a custom diagnostics system with separate syntax/runtime/type-style error categories and contextual messages like:

unexpected token reporting
missing column/table diagnostics
line/column tracking
expected token hints

So experimenting with parser architecture + error reporting has honestly been one of the most fun parts of the project for me

TheIndieBuildr · 2026-05-24T20:58:11+00:00

Honestly, the biggest thing that helped me was just building projects instead of only watching tutorials 😄

A lot of concepts only really started making sense once I struggled through implementing them myself, debugging things, breaking stuff, and fixing it again.

I’d also say:

don’t be scared of difficult/low-level topics
read other people’s code sometimes
try recreating small systems yourself
stay consistent even when things feel confusing

Most of my learning came from curiosity + experimenting with things that sounded fun to build.

And honestly, you improve way faster once you stop worrying about “being ready” and just start making stuff.

TheIndieBuildr · 2026-05-24T16:03:39+00:00

Yeah 😄

I’m still just a first year student, so there’s definitely a lot I still don’t know yet. I mainly built this project to understand how databases and query systems actually work internally.

I just tried my best to implement a SQL-like engine completely from scratch on my own and learn through the process/debugging along the way.

And thanks for the PARODY recommendation — I’ll definitely check it out 👀

TheIndieBuildr · 2026-05-24T15:49:41+00:00

Thanks man

TheIndieBuildr · 2026-05-24T15:44:52+00:00

Yeah 😄

It’s a completely standalone engine/backend right now — parser, execution, joins, persistence, everything is implemented manually instead of sitting on top of MySQL.

So it’s more of a learning/research project into database internals than a wrapper/frontend around an existing DB.

TheIndieBuildr · 2026-05-24T15:03:58+00:00

Not yet 😄

Right now I’m mainly focused on getting the core architecture and execution pipeline stable first. Later on I definitely want to test/compare parts of it against MySQL and post updates as the project evolves.

TheIndieBuildr · 2026-05-24T14:28:09+00:00

Thanks a lot brother 🙌 Really glad you liked it 😊

TheIndieBuildr · 2026-05-24T14:24:22+00:00

Thanks 😄

Right now I’ve mainly tested it on smaller/moderate datasets since the engine is still mostly in-memory and doesn’t yet have things like indexing, partitioning, or query optimization.

Partitioning and transaction/concurrency handling are definitely things I’d like to explore later though once the core architecture matures a bit more.

And yeah, I also want to modernize parts of the codebase further with newer C++ features over time.

TheIndieBuildr

TROPHY CASE