permalink	/
title	Comp Language

Comp is an experimental project to build a general purpose, high level programming language that works inside and alongside Python. It is definitely inspired by Python but contains substantial new concepts. The goal is a developer focused language that makes development better.

• Lightweight syntax Flexible syntax that with no delimiters, is not line or indentation based, and avoids nesting.
• Declarative Defined namespaces avoid circular puzzles and moves problems to build-time, not run-time.
• Builtin Schemas Define your own shapes and data types with extensible validations. Then use them to validate and transform your data.
• Data Driven Functions run on any compatible data; like having methods without the classes or casting hurdles.
• Flow Control Functions The standard library provides conditionals loops, and more; or define and or extend your own.
• Immutable values Nothing is modified once it exists. The language has the tools to define modifications the easy and safe way.

Hopefully Comp's strengths and abilities are clear when reading through the standard libraries, which are clean and idiomatic. How do your own favorite language libraries compare?

Example

/// Display recent starred issues from a GitHub repository.
// Inspired by https://julianhofer.eu/blog/2025/nushell/

!import gh comp "github-comp@1.0.2"
!import table comp "table-formatter"

!main console (
    !ctx repo "nushell/nushell"
    !my cutoff [datetime.now] - 1#week

    [gh.issue-list fields={"created-at" "reaction-groups" "title" "url"}
    | where :($.created-at >= cutoff)
    | map :($.thumbs = [$.reaction-groups | count :($.content == "thumbs-up")])
    | sort reverse :($.thumbs)
    | first 5
    | select {"thumbs"="👍" "title" "url"}
    | table.markdown
    ]
)

Additional Concepts

Comp's novel features have been carefully assembled into a language that minimizes developer friction and maximizes composability.

• Struct The structure container works as an array and a mapping.
• Tags Predefined, hierarchical enumerations.
• Failures Easier to handle than traditional exceptions.
• Contexts Tracked data that work like typed environment variables at any level of the language.
• Documentation Comments follow Rust rules for identifying documentation.
• Overloads Alternative implementations avoid conditional nests.
• Wrappers Like decorators but for statements, not just functions.
• Blocks Any statement is a deferred block and passed to functions for evaluation.
• Imports Powerful import system integrates with downloads, caching, and more.
• Compilers Multiple compilers allow compile time access to other languages and data formats.
• Formatting Rich text formatting functions are built in.
• Purity Simple functions with no side effects, that integrate with language features.
• Kebab Case Use idiomatic kebab-case for identifiers and fields.
• Functional Practical and composable pipelines.
• Numbers Represented as hardware independent values of lossless precision.
• Units Extensible subtypes attached to values, like units of measurement.
• Limits Extensible type requirements like minimum values, managed at build time.

Discover

There examples provide a variety of lightweight, real-world concepts.

The design documents go into all these concepts in further detail.

• Syntax and Style brackets, operators, formatting, the grammar rules
• Structures and Shapes immutable data, type system, tags, decorators
• Functions and Blocks pipelines, dispatch, streams, invocation
• Modules and Imports namespaces, dependencies, schema imports
• Core Types numbers, text, booleans, comparison, units

Design

What a fantastic journey this has been. There's so much potential for Comp, but it still has a long way to go. Along the way I've been introduced to a massive amount of great ideas. I'll call out a few special acknowledgements.

• Python is where I get the most out of my development
• Nushell spectacular job with their syntax and approachability
• Rhombus showing me all these functional ideas in a style I appreciate
• Cue kicked off so many ideas of merging data and definition

Getting Started

Any Python interpreter is a home for Comp. The runtime and tools run as regular Python modules themselves.

$ uv install comp-lang
$ uv run comp hello.comp

Unfortunately, comp hasn't landed in Pypi yet, so for now that means clone the git repository for yourself.