DEV Community

Void
Void

Posted on

Building Arc: A Programming Language Written in C

#c #computerscience #programming #showdev

For the past month, I've been building Arc, a programming language written in C.

As someone who started coding roughly a year ago, I wanted a project that would push me beyond application development and into language implementation.

The project started as a way to learn more about interpreters, language design, parsing, and runtime systems. Over time, it evolved into something much larger: a language that aims to stay simple while remaining powerful enough for real scripting and automation tasks.

Repository: https://github.com/VxidDev/Arc

Why Build Yet Another Programming Language?

Programming languages are one of the best ways to learn how software works beneath the surface.

Building Arc forced me to understand:

  • Lexical analysis
  • Parsing
  • Abstract Syntax Trees (ASTs)
  • Runtime execution
  • Symbol tables
  • Error handling
  • Memory management

Instead of reading about these topics, I wanted to implement them myself.

Design Goals

Arc is heavily inspired by the simplicity of languages such as Python and Lua.

The goals are:

  • Easy-to-read syntax
  • Small and understandable implementation
  • Fast iteration on language features
  • Lightweight scripting capabilities
  • Potential for embedding into larger applications

At the same time, I want to keep the implementation straightforward enough that contributors can understand how the entire language works.

Current Features

Arc currently includes:

  • Lexer
  • Parser
  • AST generation
  • Tree-walking interpreter
  • Variables
  • Functions
  • Control flow statements
  • Error reporting
  • Basic type system

Example:

VAR i = 0

WHILE i < 10
    PRINT(i)
    i = i + 1
END
Enter fullscreen mode Exit fullscreen mode

Challenges

The hardest parts so far haven't been adding new features.

They've been:

  • Designing clean language semantics
  • Managing memory correctly
  • Avoiding interpreter architecture mistakes
  • Improving diagnostics and error messages

It's surprisingly easy to add syntax. It's much harder to keep a language coherent as it grows.

What's Next?

Some areas I'm currently working on:

  • Better error messages
  • More standard library functionality
  • Further interpreter optimizations
  • Stabilizing the type system
  • Exploring a future bytecode VM

What I've Learned

The biggest lesson so far is that programming languages are much more than parsers and syntax.

A language is a collection of design decisions. Every new feature affects readability, maintainability, implementation complexity, and future growth.

Building Arc has been one of the most educational projects I've worked on.

If you're interested in language design, interpreters, or compiler construction, feedback is always welcome.

Repository: https://github.com/VxidDev/Arc

Top comments (0)