Umpteen is a general-purpose programming language currently in active development being bootstrapped from Rust


The Umpteen Programming Language

This repository provides the reference implementation for the Umpteen Programming Language, bootstrapped from Rust. Umpteen is currently in active development and frequent breaking changes are expected until v1.0.x

As such, Umpteen is not yet recommended for use in production



Write a line comment with # or a block comment with opening and closing ###

# This is a line comment

This is a block comment
Continued over multiple


Create mutable or immutable* bindings with var and let respectively

var x = 10; # x is mutable
let y = 20; # y is immutable
x = 0; # OK ✅
y = 0; # ERROR 🚫

*NOTE: Immutable bindings are not yet implemented


# Global Scope

let a = 10;
print(a); # 10
  # Block-scope
  print(a); # 10

  let a = 20;
  print(a); # 20

print(a); # 10


Immutable bindings support shadowing within the same scope

let a = 10; # OK ✅
let a = 20: # OK ✅
a = 30; # ERROR 🚫

*NOTE: Shadowing within the same scope is not yet implemented

Mutable bindings can be reassigned, however they are not permitted to be shadowed within the same scope. Conversely, shadowing is permitted within a narrower scope

var a = 10; # OK ✅
  var a = 20; # OK ✅
a = 30; # OK ✅
var a = 40 # ERROR 🚫


Test an expression with the if keyword

if true {
  print("This code prints!"); # ✅

if false {
  print("This code is unreachable"); # ⛔

As well as else and else if

let something = false;
let somethingElse = false;

if something {
} else if somethingElse {
  print("Something else!");
} else {


Execute statements multiple times with the loop keyword. Use break to exit early from the loop body, or continue to halt execution of the current iteration and skip to the next one

var i = 0;
loop {
  i += 1;

  if i > 10 {


Declare a function with the fnc keyword. Parameters require type annotations. Annotations for return types are required, unless the function returns Empty

fnc fib(n: Number) -> Number {
  if n <= 1 {
    return n;

  return fib(n - 2) + fib(n - 1);

Data Types*

  • Empty: No value
  • Boolean: true or false
  • Number: IEEE 754 double-precision floating point representation of numerics
  • String: A series of characters
  • Object: Compound data types passed by reference instead of by value
    • Fnc: Function type representing a discrete collection of executable instructions
      NOTE: User-defined functions are not yet implemented
    • List: Dynamic Array type, representing a one-dimensional dynamically resizeable numerically indexed collection

*NOTE: The full specification for Umpteen's type system is not yet defined, definition of all types is subject to change prior to v1.0.x

WARNING: Umpteen is still in active development and frequent breaking changes are expected prior to v1.0.x. Not yet recommended for production use!

You might also like...
General Rust Actix Applications and AWS Programming Utilities

RUST Actix-Web Microservice Our Rust Beginners Kit for Application Development A collection of sample code using the actix rust framework to A) Develo

I'm currently learning Rust and these are my first programs with this language

learning-Rust I follow the Rust by example official doc for learning That is also available in 'doc pdf' alongside another great rust learning sheet I

An Interpreter for Brainfuck programming language implemented in the Rust programming language with zero dependencies.

Brainfuck Hello, Visitor! Hey there, welcome to my project showcase website! It's great to have you here. I hope you're ready to check out some awesom

a chess engine written in rust. not even close to being done

Goals improve at the rust programming language. my first major project tought me how to do things in rust. I hope for this project to teach me how to

Simple console input macros with the goal of being implemented in the standard library.

Simple console input macros with the goal of being implemented in the standard library.

A simple crate, that protects some variables from being modified by memory tampering tools.

Crate: protected_integer A simple crate, that protects some variables from being modified by memory tampering tools. Usage Add this crate to dependenc

being Ariel's best friend!
being Ariel's best friend!

Sebastian se·bas·tian - sɪˈbæstɪən A simple tool used to access UniMi services -- mainly ariel, but not only -- via CLI. Important: state First of all

Safer Nostr is a service that helps protect users by loading sensitive information (IP leak) and using AI to prevent inappropriate images from being uploaded.

Safer Nostr is a service that helps protect users by loading sensitive information (IP leak) and using AI to prevent inappropriate images from being uploaded. It also offers image optimization and storage options. It has configurable privacy and storage settings, as well as custom cache expiration.

global state management for dioxus built on the concept of atoms. currently under 🏗

Fermi: A global state management solution for Dioxus, inspired by Recoil.Js Fermi provides primitives for managing global state in Dioxus applications

  • Functions


    Support for user-defined functions as well as a handful of native built-ins

    The sample program is no longer implemented with speculative syntax, although it is not working as of yet.

    The sample program now correctly implements the recursive fibonacci algorithm

    Rename RuntimeError to more semantically accurate InterpretError

    Remove outdated bytecode-related files

    Remove txt extension from history file

    opened by 347Online 0
  • Beginnings of Functions

    Beginnings of Functions


    • Replace intrinsic Print Statement with a native built-in print() function, in addition to new functions time() and str(x)
    • Break, Continue, Return, and Exit now belong to a dedicated Divergence error type which can be coerced to a Runtime Error when used in an invalid context
    • Lexer now recognizes the fnc token for functions, however User Defined Functions are not yet implemented. Parsing of fnc declarations is currently limited to displaying debug information about the parsed construct (
    • Support for both Line and Block comments
    • Support for += operator and its relevant counterparts for other arithmetic operators
    • Support string concatenation with the + and += operators
    • Support for Logical OR, AND operators
    • Rename 'Asterisk' token to 'Star' to facilitate better ergonomics when referring to the multiplication operator
    • Keyword for literals representing the empty value is now empty (lowercase e) in order to distinguish it from the similarly named type Empty (capital E). This has the added benefit of greater consistency with boolean literals
    • Catch function in lexer to provide greater ergonomics and readability, similar to the catch! macro in the parser. It is worth noting that this function in its current form is unfortunately not sufficiently sophisticated for lexing block comments. A worthwhile future addition would be to enhance this functionality, or support it with a macro to improve readability
    • New representation for Object values to facilitate pass by reference. Currently the Display impl for this is using unsafe with insufficient soundness guarantees. This will require future work to ensure this cannot lead to UB, or a safe alternative will need to be found
    • Encodes error messages differently, Umpteen Values are now stringified prior to error reporting, as future versions of the Value type may require lifetime annotations, which would otherwise need to be propagated to the error types. This provides a substantial savings in complexity, while retaining enough information to report useful errors
    • Opts in to some unstable features of the nightly compiler, most notably let-chains. This is sub-optimal, but was ultimately necessary to reasonably facilitate the current representation of values passed by reference. Ideally, support for the stable toolchain should be considered a blocker for the project to reach version 1.0.x
    • Removes currently unused StackItem type. A future version of this type will need to return for the compiled variant, however it will likely need to be completely rethought, given the degree to which the parse logic is still being defined
    • Add boxed! utility macro
    • Add VSCode Launch configuration for running with attached debugger
    opened by 347Online 0
  • Proper expressions

    Proper expressions

    Greater ergonomics for calls to report_* utils

    Rename Value and Variable expressions to more semantically accurate 'Literal' and 'Binding' respectively

    Append Eof token in lexer and report Unexpected Symbol errors, obviating SyntaxError type and Error token

    Additional Operators and ops now implement Clone, Copy, and TryFrom

    Properly parsing nested expressions via recursive descent

    • Macros improve readability of logic at the callsite while drastically reducing the need for boilerplate
    • Parse methods for different precedence levels (credit Robert Nystrom)
    opened by 347Online 0
Katie Janzen
Hi! I'm Katie, your friendly neighborhood transgender games vendor! Nice to meetcha! :D
Katie Janzen
CLI for self-bootstrapped Python applications

PyApp PyApp is a CLI wrapper for Python applications that bootstrap themselves at runtime. Each application is configured with environment variables a

Ofek Lev 6 May 10, 2023
General purpose memory allocator written in Rust.

Memalloc Memory allocator written in Rust. It implements std::alloc::Allocator and std::alloc::GlobalAlloc traits. All memory is requested from the ke

Antonio Sarosi 35 Dec 25, 2022
A simplified general-purpose queueing system for Rust apps.

A simplified general-purpose queueing system for Rust apps. Example // Create a new Redeez object, and define your queues let mut queues = Redeez::new

Miguel Piedrafita 11 Jan 16, 2023
General purpose cross-platform GIS-rendering library written in Rust

Galileo is a general purpose cross-platform geo-rendering library. Web examples Raster tile layer (OSM) Vector tile layer (Maplibre) Use buttons at th

Maxim 16 Dec 15, 2023
A general-purpose, transactional, relational database that uses Datalog and focuses on graph data and algorithms

cozo A general-purpose, transactional, relational database that uses Datalog for query and focuses on graph data and algorithms. Features Relational d

null 1.9k Jan 9, 2023
A small Rust library that let's you get position and size of the active window on Windows and MacOS

active-win-pos-rs A small Rust library that let's you get position and size of the active window on Windows and MacOS Build % git clone https://github

Dmitry Malkov 21 Jan 6, 2023
Active Directory data collector for BloodHound written in Rust. 🦀

RustHound Summary Limitation Description How to compile it? Using Makefile Using Dockerfile Using Cargo Linux x86_64 static version Windows static ver

OPENCYBER 575 Apr 25, 2023
Nvm - Node Version Manager - POSIX-compliant bash script to manage multiple active node.js versions

Node Version Manager Table of Contents Intro About Installing and Updating Install & Update Script Additional Notes Troubleshooting on Linux Troublesh 63.8k Jan 7, 2023
Show active TCP connections on a TUI world map.

Maperick Show active TCP connections on a TUI world map. Still WIP, but it's gonna be good. Setup git clone [email protected]:schlunsen/maperick.git cd m

Rasmus Schlünsen 5 Jul 8, 2022
Tracing layer that automatically creates and manages progress bars for active spans.

tracing-indicatif A tracing layer that automatically creates and manages indicatif progress bars for active spans. Progress bars are a great way to ma

Emerson Ford 95 Feb 22, 2023