I had an idea for a small programming language and want to know whether it makes sense. The language would let me teach the compiler how to implement an operation by supplying assembly code, something like:
teach get(x):
asm:
; assembly instructions for getting input
After defining it once, I could write get(age) elsewhere and have the compiler insert or call the assembly implementation automatically. The goal is a simple language that can still produce native machine code without already having built-in knowledge of every operation.
Is this technically possible, and would it be a worthwhile project? I'm new to low-level programming and compiler design, so I'd appreciate corrections about how this idea relates to functions, macros, inline assembly, assemblers, and compilers.
4 Answers
Yes, it’s possible, but the core idea is essentially a function implemented with inline assembly. You define the assembly once, associate it with a name and parameter types, and then call it later. Many languages and compiler toolchains already support some version of this.
It could still be an excellent learning project. Building a tiny language that parses function definitions, handles calls, and emits assembly would teach you a lot about lexing, parsing, calling conventions, assemblers, and code generation.
A practical design might treat the assembly block as a platform-specific function rather than something the compiler learns in an intelligent way. Give it a name, input and output types, and a target architecture, then have the compiler emit a call to it. You could also study Forth-style languages for inspiration, since they expose low-level operations while keeping the programming model relatively small.
There are good reasons most programs don’t implement everything directly in assembly. Modern C and similar compilers can often generate highly optimized machine code, and they understand things your custom compiler would need to handle, such as register allocation, instruction scheduling, optimization, memory rules, and calling conventions. Handwritten assembly is most useful when you need precise hardware control or a specialized performance improvement.
The biggest challenge is that assembly is tied to a particular target. Code written for x86-64 won’t generally work on ARM, and even different operating systems can use different calling conventions and system interfaces. Supporting multiple platforms would mean providing separate implementations for each architecture, or generating lower-level code through a backend for each target.
It’s also somewhat similar to a macro system: define a reusable piece of low-level code and expand or call it wherever it’s needed.