I'm Bored!! Lets design a Programming Language (Part-1)

By Daniel Samson · 2026-05-25

For over 8 years, I have been longing for a programming language that has the development experience of Spring Boot or Laravel, but with the performance and safety of rust. Am i reaching for the stars? Maybe. But I think it's possible to create a language that is easy to learn and use, but also powerful and efficient. Domain Specific languages are a great way to achieve this, and I think a language that is specifically designed for creating rapid web servers and cli apps would be a great addition to the programming world.

Requirements

MUST have syntax that is easy to read and consistent (like python), hygienic (like rust)
Code written by an expert looks indistinguishable from a novice (like Go)
It must be able to produce a cli binary with a high performing web server.
MUST be object oriented, with the ability to invoke objects like functions.
Have excellent serialization and deserialization support
have a build in high performance router for http request
MUST have a A Network Server that natively supports TLS, HTTP, HTTP 2, gRPC
MUST have a excellent database connector support.
code style is enforced by the compiler, which auto fixes files when it can
code and file support spaces NO more FOO_BAR, BAZ-FOO, BazFoo etc.
Multi Threading support built in
Memory Safe and Thread Safe with strong types
Built-in Top Class Package Management (versioned)
Built-in Dependency Injection support
Support for versioned dependencies
Easy to understand compilation error messages with helpful hints
One file must only contain 1 object
Rust style enumerators

Marketing

So it am going to steal from rusts build tool cargo, and call my build tool pallet (get it?). Both the language and the build tool are one and the same. One tool to do it all. Pallet source code units will be broken up into files with the pallet language extension *.pal.

Empty Project

An empty project starts with a directory with a pallet.pal definitions. Like rust a project or package is called a pallet. a workspace can be made up of multiple pallets.

// pallet definition pallet.pal:
{
  depends on: {
    pallet: "^1.0"            // language version
    operating system: "^1.0"  // standard library pallet
  } : override
  exports : {                 // pallets to export into a library file
    source/hello world: binary       // hello world.pal is a binary instead of a statically/dynamically linked library
    // library/my static library: static
    // library/my dynamic library: dynamic
  } : override
} : pallet definition               // implements pallet definition interface

It helps to define the dependencies, which binaries, libraries it exports. A pallet definition is just a pallet source code file which implements the pallet definition interface.

// source/hello world.pal:
{
  imports: {                // imports keyword to import functions from other pallets
    print: operating system // standard library pallet
  } : interface
  exports: {                // export methods to other 
    add: public
    subtract: protected
  } : interface
  my property: text ""
  constructor: method     // default constructor
    self: current object
    arguments: object of text 
    {
      // convert the first cli argument from a string to a number
      a: number arguments->1
      // convert the second cli argument from a string to a number
      b: number arguments->2
      // print to the screen
      self->imports->print 
        "a: " ... this -> a ... " + b: " ... this->b ... " = "
        self -> add
          a: this->a
          b: this->b
    } : implements nothing
  add: method
    a: decimal
    b: decimal
    { a + b } : implements decimal
  subtract: method 
    a: decimal
    b: decimal
    { a + b } : implements decimal
} : interface

Identifiers

Identifiers are a sequence words which can be referenced in a source code unit.

Types

Types are reserved identifiers by the language. The nothing type is a special type that represents nothingness. The interface is the bases of all types.

All types implements one or more interfaces, a set of properties (values) and methods (functions). Methods can return an implementation of an interface or nothing.

The methods on an interfaces may implement nothing, but objects using that interface must implement those methods.

Primitives are special interfaces that represent CPU level values/primitives

sizeint : primitive
usizeint : primitive
int8 : primitive
uint8 : primitive
int16 : primitive
uint16 : primitive
int32 : primitive
uint32 : primitive
int64 : primitive
uint64 : primitive
float : primitive
double : primitive
decimal : primative
character : primative

Container types hold many instances of primitives or interfaces.

vector : interface of a primitive (dynamically sized memory)
array : interface of primitive (fixed sized of contigous memory)
enumerator : object
text: vector/array of characters

Operators

: implements an interface or is a representation of a type
-> access object/array properties or elements