Nubo: My Fun Little Programming Language Project

It is not trying to replace every programming language.

It is more like a playground where I can try language ideas, build scripts, render HTML, make small web apps, and experiment with how a language could feel.

The main goal is simple: make coding feel clean, readable, and enjoyable.

What is Nubo?

Nubo is a programming language with a simple syntax and some web-friendly features.

You can write normal code like this:

const name = "Nubo"
let count = 0

println(`Hello from {name}`)

It has variables, functions, loops, imports, types, arrays, dictionaries, and other basic language features.

But it also has some extra things that make it fun, like built-in HTML support.

Why I Built It

I built Nubo because programming languages are fun.

I wanted to understand how languages work internally: parsing, evaluating code, handling variables, imports, functions, types, and all the little details that usually stay hidden.

Nubo started as an experiment, but it became a real little language that can run scripts and even build small web apps.

It is still a fun project, but it is also useful enough to make real demos with.

The Core is Nubo

For real expression operations like +, -, comparisons, and similar calculations, Nubo uses expr-lang/expr.

That helps with evaluating expressions reliably instead of reinventing every tiny operation from scratch.

But the core language is still Nubo.

The syntax, imports, functions, HTML templates, components, routing ideas, and the way .nubo files work are all part of Nubo itself.

So expr helps with expression evaluation, but Nubo is the actual language around it.

Simple Scripts

Nubo works nicely for scripts.

For example, you can read data, loop through it, count values, and print results:

for item in data {
    const author = item[4][0]

    if author.includes(input) {
        count++
    }
}

This kind of code is simple, but that is the point. Nubo is meant to keep small tasks readable.

It is good for experimenting, school-style tasks, data processing, and quick automation.

Built-in HTML

One of my favorite parts of Nubo is that HTML can be written directly inside the language.

const page = <main>
    <h1>Hello Nubo</h1>
    <p>This HTML is written inside Nubo.</p>
</main>

This makes it possible to build pages without switching between a separate template language and normal code.

HTML feels like a natural part of the language.

Components as Functions

Nubo can also use functions as components.

fn Button(text: string) html {
    return <button>{text}</button>
}

This makes UI code easy to split into smaller pieces.

A layout, form, copy box, table, or full page can just be a function that returns HTML.

That makes Nubo fun for small web apps, because the structure stays very simple.

Web App Experiments

Nubo can also be used for small server-side web apps.

One demo project is a URL shortener. It has a form, app logic, a small database layer, reusable components, and redirects.

That project shows the direction I want Nubo to explore: small apps that do not need a huge framework to feel organized.

You can write a route, read a request, call some app logic, and return HTML.

That is simple, but powerful enough for fun projects.

Imports and Standard Libraries

Nubo supports imports from local files and standard libraries.

import io from "@std/io"
import request from "@server/request"
import { redirect } from "@server/response"

This makes projects easier to split up.

Helpers can go in one file, components in another, app logic somewhere else, and the main route can stay clean.

Typed, But Still Lightweight

Nubo has types, but it tries not to feel too heavy.

const numbers: []int = []
let code: string? = nil

Types help make the code clearer, especially when working with arrays, dictionaries, functions, and optional values.

But the language still tries to stay small and easy to read.

What Makes Nubo Fun

Nubo is fun because it mixes a few different ideas:

scripting
typed values
imports
built-in HTML
reusable components
server-side routes
simple app structure
expression evaluation powered by expr
a custom language core

It is a small project, but it already has enough features to build interesting things.

Final Thoughts

Nubo is still young, but that is part of the fun.

It is a project for learning, experimenting, and building small things in a language that feels personal.

The best part is that it keeps growing. Every feature teaches something new about how programming languages work.

Nubo may not be a huge language, but it has its own style: simple syntax, readable code, HTML built in, and a core built around experimenting with fun ideas.