HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
rochus-keller
Oberon
C++2019–2026
rochus-keller / Oberon

Oberon

Oberon parser, code model & browser, compiler and IDE with debugger, and an implementation of the Oberon+ programming language

9Distinct people
71Mentions
0Explicit recommenders
557GitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

Oberon parser, code model & browser, compiler and IDE with debugger, and an implementation of the Oberon+ programming language

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

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 4:43:50 AM UTC.

Show HN: Micron – Oberon with the Power of C direct repository linkFavorable

The discussion highlights appreciation for the Micron language as a modern, practical evolution of Oberon that successfully integrates C-like power with rigorous type safety and single-pass compilation heritage. While users praise the comprehensive examples and clear textbook, a substantive debate emerges regarding whether prioritizing simple, fast compilers restricts access to advanced features like dependent typing compared to more complex modern systems.

24 readable replies · Supporting reply 1 · Supporting reply 2

Mentions over time

HN mentions by year71 dated mentions

Observed mentions: 2019-10-30 16:57:11 UTC to 2026-09-25 15:02:32 UTC.

0510152019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments20192020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 10 mentions; 1 submissions, 9 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 14 mentions; 8 submissions, 6 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 11 mentions; 3 submissions, 8 comments20222023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 8 mentions; 0 submissions, 8 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 9 mentions; 0 submissions, 9 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 11 mentions; 0 submissions, 11 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 7 mentions; 0 submissions, 7 comments. Incomplete calendar period.2026*

* 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.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC101
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC1019
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC1486
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC1138
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC808
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC909
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC11011
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC707

What Hacker News says

9 sources
It's also a completely different approach. Probably additional performance could be gained by implementing JIT support for additional LuaJIT bytecodes. But we cannot predict how significant this gain would be. If the concept has limitations, more money likely doesn't change much. We can also compare with the old Mono 3 version developed by a rather small company (Xamarin, before they were bought by MS), which follows yet another approach than V8 or LuaJIT, and which achieves about the same performance as V8; see https://github.com/rochus-keller/Oberon/blob/master/testcase....
In Lua is so underrated
It's not about a "final conclusion", just about a summary of the measurement results at hand. Instead of letting the user to trawl through a lot of documents and figures and make geomean and factors calculations him/herself, the author who publishes measurement results should do this. Here is an example how this could look: https://github.com/rochus-keller/Oberon/blob/master/testcase.... It is immediately recognizable how much less time on average the C++ implementation used compared to the reference (LuaJIT in this case).
In Java (JIT) vs C++ (AOT) for a simple hash table
> We implement LuaJIT Remake (LJR)[...] using Deegen. Across 44 benchmarks, LJR's interpreter is on average 179% faster than the official PUC Lua interpreter, and 31% faster than LuaJIT's interpreter. Well, LuaJIT in JIT mode is about factor 3 faster on average than LuaJIT in interpreter mode (depending on the benchmark up to ten times). And LuaJIT in JIT mode is e.g. factor 8 faster on average than PUC Lua 5.1 (see e.g. http://software.rochus-keller.ch/are-we-fast-yet_Lua_results... for more information). So if Degen is factor 2 faster than PUC Lua or factor 1.3 faster than the LuaJIT interpreter, this is not very impressive. But since the LuaJIT interpreter is written in assembler, we might conclude that the speed-up of a manual assembler implementation compared to a generated interpreter is about 30%. Therefore it's no longer worth the
Read the rest
effort to implement an interpreter in assembler (even less if we consider cross-platform migration costs). But on the other hand the Degen generated VM is significantly slower than e.g. the Mono VM or CoreCLR in JIT mode (see e.g. https://github.com/rochus-keller/Oberon/blob/master/testcase...).
In Deegen: A JIT-Capable VM Generator for Dynamic Languages
Pallene unfortunately is only a subset of Lua, i.e. you cannot simply take a Lua program and compile it with Pallene. The use case of this language is not obvious to me, since if I have to re-implement the performance-critical parts of the Lua program anyway, I can just as good implement it in C using the Lua C API. Thus the claim of the Pallene authors is a bit misleading. Concerning LuaJIT performance, I have done a lot of measurements over the years (see e.g. https://github.com/rochus-keller/Oberon/blob/master/testcase...) and would rather say that its performance is about factor four worse on average than an equivalent C++ -O2 compiled program. For some exceptional use cases it might perform as good as C, but not in general (one reason is the missing tracing JIT support for closures).
In Pallene: A statically compiled companion language for Lua
> Sure there's a small overhead to smart pointers Not so small, and it has the potential to significantly speed down an application when not used wisely. Here are e.g. some measurements where the programmer used C++11 and did everything with smart pointers: https://github.com/smarr/are-we-fast-yet/issues/80#issuecomm.... There was a speed down between factor 2 and 10 compared with the bare-bone C++98 implementation. Also remember that smart pointers create memory leaks when used with circular references, and there is an additional memory allocation involved with each smart pointer. > Garbage collection has an overhead too of course The Boehm GC is surprisingly efficient. See e.g. these measurements: https://github.com/rochus-keller/Oberon/blob/master/testcase.... The same benchmark suite as above is compared with different versions of Mon
Read the rest
o (using the generational GC) and the C code (using Boehm GC) generated with my Oberon compiler. The latter only is 20% slower than the native C++98 version, and still twice as fast as Mono 5.
In Boehm-Demers-Weiser conservative C/C++ Garbage Collector
Great, thanks! There are books online for free, e.g. https://people.inf.ethz.ch/wirth/ProgInOberonWR.pdf and https://ssw.jku.at/Research/Books/Oberon2.pdf Oberon+ is a superset of Oberon 90 and Oberon-2. Here is more information: https://oberon-lang.github.io/, and here is the current language specification: https://github.com/oberon-lang/specification/blob/master/The.... I already had valuable feedback here on HN concerning the channel extensions. Further research brought me to the conclusion, that Oberon+ should support both, channels and also monitors, because even in Go, the sync package primitives are used twice as much as channels. Mutexes and condition variables can be emulated with channels (I tried my luck here: https://www.quora.com/How-can-we-emulate-mutexes-and-conditi...), but for efficiency reasons I think monitors should be
Read the rest
directly supported in the language as well, even if it might collide with the goal of simplicity. Feel free to comment here or e.g. in https://news.ycombinator.com/item?id=38903351 or in https://github.com/rochus-keller/Oberon/discussions/45.
In Niklaus Wirth, or the Importance of Being Simple
> Does anyone know why Wirth never modernized his style? Readability. It's easier to read the source code with uppercase keywords. (I think Wirth once said that code is written once but read many times). See this source code - https://raw.githubusercontent.com/rochus-keller/OberonSystem... - to get an idea of this (the uppercase keywords allow you to easily scan the blocks of code). Ofcourse, one can claim that the same can be achieved better today with colour-coded keywords. If it really bothers you, I think the Oberon+ IDE - https://github.com/rochus-keller/Oberon - gives you an option to disable this and use lowercase keywords.
In Tex-Oberon: Make Project Oberon Pretty Again

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.