Nicheloom

Market intelligence for builders — see what's gaining traction before it's crowded.

MOL

A programming language where pipelines trace themselves

Details

External ID
46977967
Source
HN
Company
—
Product
MOL
Website domain
github.com
Launched
Feb. 11, 2026
Cohort
—
Upvotes
38
Upvotes percentile
0.7756064690026954
Tags
—
Fetched at
Sept. 7, 2026, 9:25 p.m.
Updated at
Sept. 7, 2026, 9:25 p.m.

Description

Hi HN,I built MOL, a domain-specific language for AI pipelines. The main idea: the pipe operator |> automatically generates execution traces — showing timing, types, and data at each step. No logging, no print debugging.Example: let index be doc |> chunk(512) |> embed("model-v1") |> store("kb") This auto-prints a trace table with each step's execution time and output type. Elixir and F# have |> but neither auto-traces.Other features: - 12 built-in domain types (Document, Chunk, Embedding, VectorStore, Thought, Memory, Node) - Guard assertions: `guard answer.confidence > 0.5 : "Too low"` - 90+ stdlib functions - Transpiles to Python and JavaScript - LALR parser using LarkThe interpreter is written in Python (~3,500 lines). 68 tests passing. On PyPI: `pip install mol-lang`.Online playground (no install needed): http://135.235.138.217:8000We're building this as part of IntraMind, a cognitive computing platform at CruxLabx. """

Enrichment

Theme
browser automation and scraping for AI
Vertical
Horizontal
Function
Dev tools
Audience
Developer
AI stance
Not AI
Project type
Hobby / open-source project
Normalized one-liner
programming language with self-tracing pipelines
Manually corrected
False

Could you build this?

Partial The syntax and basic interpreter wrapper can be vibe-coded, but designing a reliable DSL runtime with automatic runtime tracing, type checking, and AI pipeline introspection requires compiler and language design fundamentals.

What it would actually take: The system requires a lexer, parser, and AST interpreter/compiler (likely built in Rust or Go) supporting custom pipe operators and automated execution telemetry. It requires hooks for streaming LLM outputs, asynchronous IO for embeddings/vector DB operations, and OpenTelemetry-compatible tracing infrastructure without introducing runtime overhead. This demands solid programming language design (PL) and distributed tracing expertise.

Discussion

16 comments analyzed.

Competitors mentioned: Elixir (pipe operator), Haskell (MonadTrace), F# (pipe operator), Python (operator overloading), Rust (operator overloading)

Concerns raised: Not Pythonic to use operator overloading for pipes, Performance overhead compared to native Python, Dynamic pipelines and batching execution unclear, Orphan rule violation in Rust implementation, Auto-tracing not truly automatic, still requires explicit setup

Feature requests: Examples of complex workflows and open-ended loops/agents, Clarification on dynamic pipeline support, Separate pipeline definition from execution for throughput optimization, Documentation on durable pipeline execution

Competitors

Other products that read as similar to this one — 72 launches clear the similarity bar, closest 8 shown.

Attention rank: #23 of 73 (itself plus its competitors, highest first — normalized so YC and Product Hunt are compared fairly).

Launched 98 days after the earliest competitor.

Other launches for this product

Same idea, different domain

Nobody's really built a dev tools tool for Sales yet.