manifold-systems

manifold

Java2018–2026

manifold-systems / manifold

manifold

Manifold is a Java compiler plugin, its features include Metaprogramming, Properties, Extension Methods, Operator Overloading, Templates, a Preprocessor, and more.

Explore on GitHub Read Hacker News discussions

13Distinct people

125Mentions

0Explicit recommenders

2.8KGitHub stars

REPOSITORY AT A GLANCE

What to know before exploring

What it is

Manifold is a Java compiler plugin, its features include Metaprogramming, Properties, Extension Methods, Operator Overloading, Templates, a Preprocessor, and more.

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 3:56:07 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year125 dated mentions

Observed mentions: 2018-10-30 05:10:46 UTC to 2026-07-23 19:57:57 UTC.

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges

UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
Period	Start (UTC)	End (exclusive, UTC)	Mentions	Submissions	Comments
2018	2018-01-01 00:00:00 UTC	2019-01-01 00:00:00 UTC	1	1	0
2019	2019-01-01 00:00:00 UTC	2020-01-01 00:00:00 UTC	18	15	3
2020	2020-01-01 00:00:00 UTC	2021-01-01 00:00:00 UTC	13	4	9
2021	2021-01-01 00:00:00 UTC	2022-01-01 00:00:00 UTC	2	0	2
2022	2022-01-01 00:00:00 UTC	2023-01-01 00:00:00 UTC	3	1	2
2023	2023-01-01 00:00:00 UTC	2024-01-01 00:00:00 UTC	21	5	16
2024	2024-01-01 00:00:00 UTC	2025-01-01 00:00:00 UTC	33	17	16
2025	2025-01-01 00:00:00 UTC	2026-01-01 00:00:00 UTC	19	4	15
2026 (partial)	2026-01-01 00:00:00 UTC	2027-01-01 00:00:00 UTC	15	3	12

What Hacker News says

125 sources

owlstuffing·Jul 23, 2026

You can inline native type-safe JSON directly in Java with the manifold project. /*[Dude.json/] { "Name": "Scott", "Age": 100, "Address": { "Street": "345 Syracuse Way", "City": "Atlantis" } } */ Dude dude = Dude.fromSource(); out.println(dude.getName()); out.println(dude.getAge()); out.println(dude.getAddress().getCity()); https://github.com/manifold-systems/manifold

In JEP 540: Simple JSON API (Now in Incubator)

owlstuffing·Apr 14, 2026

Analytics with type-safe raw SQL (including DuckDb’s awesome extensions) is pure gold: https://github.com/manifold-systems/manifold/blob/master/doc...

In Design and implementation of DuckDB internals

vips7L·Apr 8, 2026

It's honestly hilarious since the person you're replying to has heavily advocated Manifold which is a compiler extension to Java that adds every little feature to the language. https://github.com/manifold-systems/manifold

In Union types in C# 15

owlstuffing·Apr 8, 2026

F# units are handy, but nothing like Manifold units (Java): https://github.com/manifold-systems/manifold/tree/master/man...

In Union types in C# 15

owlstuffing·Mar 18, 2026

Kotlin's "delegation" feature isn't true delegation, it's just call forwarding, which is better than nothing, but it falls down pretty quickly as an alternative to implementation inheritance. The manifold project provides true delegation[1] for Java. 1. https://github.com/manifold-systems/manifold/blob/master/man...

In Java 26 is here

owlstuffing·Mar 18, 2026

> We now know that we prefer composition over inheritance When people say "composition over inheritance" in Java discussions, they usually mean the trivial modeling rule: prefer has-a over is-a. But that’s not what composition is really about. The deeper idea is interface composition -- building types by composing multiple behavioral contracts behind a single cohesive surface. Java provides inheritance and interfaces, but it doesn’t provide first-class delegation or traits. So most developers never really practice interface composition. They either subclass, or they wire objects together and expose the wiring. The slogan survived. The concept mostly didn’t. The manifold project, for example, experiments with language-level delegation to make interface composition practical with Java. https://github.com/manifold-systems/manifold/blob/maste

Read the rest

r/man...

In Java 26 is here

owlstuffing·Mar 10, 2026

> The drawback is that building an AST now requires a symbol table Well, yes and no. During AST building a binding expression resolves as an untyped polyadic expression. Only later during the compiler's type attribution phase does a binding expression's structure resolve based on the operand types. https://github.com/manifold-systems/manifold/tree/master/man... > in typical code you don’t have the case of constant values so often. Agreed. It's not really useful with inlined expressions: Schedule contacts.select(contactId) inputForm.getDateTime() but if you write it like: var plumber = contacts.select(contactId) var date = inputForm.getDateTime() var building = findLocation(warehouse) Schedule plumber on date at building But, honestly, I can't say I personally use it that way ;) Initially, I wrote it as a science extension

Read the rest

to Java: https://github.com/manifold-systems/manifold/tree/master/man...

In Rethinking Syntax: Binding by Adjacency

owlstuffing·Mar 10, 2026

Author here. Yes, technically this is a form of backtracking, similar to what a parser does. The key difference is that the search is drastically constrained by the type system: reductions are only attempted where the types actually support a binding operator. Unlike a parser exploring all grammar possibilities, this mechanism prunes most candidates automatically, so the compiler efficiently "solves" the expression rather than blindly exploring every syntactic alternative. Here is the high-level explanation of the mechanism: https://github.com/manifold-systems/manifold/tree/master/man... But the short answer is that it’s not parser-style backtracking over a grammar. The Java parser still produces a normal AST for the sequence of tokens. What happens afterward is a type-directed binding phase where adjacent expressions may bind if their ty

Read the rest

pes agree on a binding operator. The compiler effectively reduces the expression by forming larger typed expressions until it reaches a stable form. The algorithm favors left associativity, but since a type can implement the binding operator as either the left or right operand, the overall structure of the expression can emerge in different ways depending on the participating types. So rather than exploring grammar productions, the compiler is solving a set of type-compatible reductions across the expression. For example: 2026 March 10 reduces roughly like this: (2026 (March 10)) → March.postfixBind(2026) // → LocalYearMonth → [retreat] // → no binding with 10 → March.prefixBind(10) // → LocalMonthDay → .postfixBind(2026) // → LocalDate And if `Month` binds with `Range<Integer>`: 2026 March 10 to 13 can reduce as: (2026 (March ((10 to) 13))) The meaning is therefore determined entirely by which types participate in binding e.g., `LocalDate`, `Month`, `Integer`, `Range`, etc. and which reductions they define. If a competing interpretation exists but the types don’t support the necessary bindings, it simply never forms. In that sense it behaves less like a traditional parser and more like a typed reduction system layered on top of the Java AST.

In Rethinking Syntax: Binding by Adjacency

owlstuffing·Mar 8, 2026Submission

Optional/Named Arguments for Java

1 points · Open discussion

owlstuffing·Mar 8, 2026Submission

Rethinking Syntax: Binding by Adjacency

53 points · Open discussion

owlstuffing·Mar 8, 2026

What if these were real, type-safe expressions in Java: 2025 July 19 // → LocalDate 300M m/s // → Velocity 1 to 10 // → Range<Int> Schedule Alice Tues 3pm // → CalendarEvent That's the idea behind binding expressions — a compiler plugin I built to explore what it would mean if adjacency had operator semantics. It lets adjacent expressions bind based on their static types, forming new expressions through type-directed resolution. Details here: https://github.com/manifold-systems/manifold/blob/master/doc...

In Rethinking Syntax: Binding by Adjacency

owlstuffing·Mar 2, 2026Submission

Type-Safe JDBC: Schema-First Native SQL in Java

3 points · Open discussion

owlstuffing·Feb 18, 2026

Something parallel to this and completely amazing: manifold-sql[1]. 1. https://github.com/manifold-systems/manifold/blob/master/man...

In Show HN: Pg-typesafe – Strongly typed queries for PostgreSQL and TypeScript

jeroenhd·Feb 1, 2026

Type inference is part of every modern language. Structural typing not so much, though. Java has it through a compiler extension (https://github.com/manifold-systems/manifold/tree/master/man...) but I don't know many other languages that support this feature. As much as I dislike the entire Javascript runtime environment, I find TypeScript to be the best typing system out there for any imperative language.

In The history of C# and TypeScript with Anders Hejlsberg [video]

owlstuffing·Jan 16, 2026

100% agree. > Writing SQL code Language integration is paramount for med/lg projects. There's an experimental Java lang project, manifold-sql [1], that does the impossible: inline native DuckDB SQL + type-safety. """ [.sql/] SELECT station_name, count(*) AS num_services FROM 'http://blobs.duckdb.org/train_services.parquet' WHERE monthname(date) = 'May' GROUP BY ALL ORDER BY num_services DESC LIMIT 3 """ .fetch() .forEach(row -> out.println(row.stationName + ": " + row.numServices)); 1. https://github.com/manifold-systems/manifold/blob/master/doc...

In Why DuckDB is my first choice for data processing

Showing the 15 most recent of 125 sources. Enable JavaScript to search and browse every indexed mention.