Road — RoadC implementation

The Road. Pave Tomorrow.

We access it all at RoadOS.
We collaborate with Roadies.
We code in Road.

Integration is Innovation.

Pick up your Roadies. Discover the BlackRoad together.

Product names, brand language, and implementation boundaries

A Road language implementation with Python-style indentation, built from scratch — a tree-walking interpreter in Python and a zero-dependency C99 compiler.

What Works Today

The Python interpreter supports:

• Variables: let, var, const with optional type annotations
• Functions: fun keyword, parameters, return, recursion, closures
• Control flow: if/elif/else, while, for/in, break, continue
• Types: integers, floats, strings (with {var} interpolation), booleans, colors (#FF1D6C)
• Collections: lists, dicts, sets, tuples, ranges
• Operators: arithmetic, comparison, logical, bitwise, compound assignment
• Builtins: print, len, range, str, int, abs, min, max, sorted, input, and more
• Member access: string/list/dict methods (.upper(), .append(), .keys())

fun fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

let result = fibonacci(10)
print(result)  # 55

let name = "world"
let msg = "hello {name}"
print(msg)  # hello world

let xs = [1, 2, 3, 4, 5]
let total = 0
for x in xs:
    total += x
print(total)  # 15

Architecture

source.road
    |
    v
  Lexer (lexer.py, 462 LOC)
    |  Tokens: keywords, literals, operators, INDENT/DEDENT
    v
  Parser (parser.py, 826 LOC)
    |  AST nodes defined in ast_nodes.py (462 LOC)
    v
  Interpreter (interpreter.py, 320 LOC)
       Tree-walking execution with Environment chain

The C compiler (roadc.c, 618 LOC) is a separate implementation that compiles .road files to native executables. Zero external dependencies — just a C99 compiler.

gcc -std=c99 -O2 -o roadc roadc.c
./roadc program.road

Development

# Run a .road file
python3 roadc.py run examples/demo.road

# Run tests (30+ tests)
pytest tests/ -v

# Build C compiler
gcc -std=c99 -O2 -o roadc roadc.c

# Start REPL
python3 roadc.py repl

Roadmap

• Type checker (static analysis pass between parser and interpreter)
• Bytecode VM (replace tree-walking for performance)
• Standard library (file I/O, math, networking)
• 3D scene graph (space, cube, sphere keywords — lexer ready, runtime not yet)
• Package manager
• Self-hosting compiler

License

Proprietary — BlackRoad OS, Inc.

Related Projects

Project	Description
RoadC Playground	Interactive browser IDE for RoadC
Universal Computer	Turing machine simulator
Quantum Math Lab	Mathematical computation toolkit

---

About BlackRoad

BlackRoad is the ecosystem. RoadOS is the portable computer and control environment where people access their work and Roadies can operate visibly within authorized boundaries. Roadies are AI collaborators; Roadie is the coordinating meta-AI; Road is the language.

RoadC is an implementation of Road. The Python interpreter and C compiler described above are implementation tools, not separate product definitions. Local operation, dependencies, supported syntax, and compatibility must be assessed for each implementation.

Ramps are connections to external providers and services. Their use follows explicit permissions and the implementation’s actual data flow. The shared canon makes no blanket claim of zero dependencies, universal hardware support, or connected production infrastructure.

Built by BlackRoad OS, Inc..

The BlackRoad ecosystem

Organization	Focus
BlackRoad OS	Core platform and applications
BlackRoad OS, Inc.	Corporate and enterprise
BlackRoad AI	Artificial intelligence and ML
BlackRoad Hardware	Edge hardware and IoT
BlackRoad Security	Cybersecurity and auditing
BlackRoad Quantum	Quantum computing research
BlackRoad Agents	Autonomous AI agents
BlackRoad Network	Mesh and distributed networking
BlackRoad Education	Learning and tutoring platforms
BlackRoad Labs	Research and experiments
BlackRoad Cloud	Self-hosted cloud infrastructure
BlackRoad Forge	Developer tools and utilities

Links — blackroad.io · docs.blackroad.io · chat.blackroad.io · search.blackroad.io

Remember the Road. Pave Tomorrow.

RoadOS source integration

Browse this clone's committed source in RoadOS Code and import selected files with commit/blob provenance. Setup and language compatibility.

Offline ecosystem check

This repository declares its integration role and required files in ecosystem.json. With road, RoadOS, roadies, roadc, roadie, and BlackRoadOS-RoadOS as sibling checkouts, run from their parent:

python3 RoadOS/ecosystem.py --root .

The checker reports all six components, hashes required files, and checks that their canon copies agree. It does not execute repository code, load models, connect providers, or establish deployment readiness. See the ecosystem contract.

Compare local observations

From the parent of the six sibling checkouts:

python3 RoadOS/ecosystem.py --root . --save baseline.json
python3 RoadOS/ecosystem.py --root . --baseline baseline.json --save current.json

Snapshots preserve file hashes and canon agreement across Road, RoadOS, and Roadies. The comparison identifies changed, newly observed, or no longer observed files. Existing snapshot files are never overwritten. These checks do not run repository code or connect providers. See comparison behavior and exit codes.