Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > ger.ct > #656293 > unrolled thread

Compiler + KI

Back to article view | Back to ger.ct

Contents

  Compiler + KI Lars Gebauer <lgebauer@live.de> - 2026-02-06 12:57 +0100
    Re: Compiler + KI Carlo XYZ <carloxyz@invalid.invalid> - 2026-02-06 20:41 +0100
    Re: Compiler + KI Gerrit Heitsch <gerrit@laosinh.s.bawue.de> - 2026-02-08 09:41 +0100
      Re: Compiler + KI Dietz Proepper <dietz.usenet@rotfl.franken.de> - 2026-02-08 12:02 +0100
      Re: Compiler + KI Hendrik van der Heijden <hvdh@gmx.de> - 2026-02-08 12:32 +0100
        Re: Compiler + KI Dietz Proepper <dietz.usenet@rotfl.franken.de> - 2026-02-08 13:02 +0100
    Re: Compiler + KI Hermann Riemann <nospam.ng@hermann-riemann.de> - 2026-02-08 15:04 +0100
      Re: Compiler + KI Dietz Proepper <dietz.usenet@rotfl.franken.de> - 2026-02-08 15:32 +0100
      Re: Compiler + KI Gerhard Hoffmann <dk4xp@arcor.de> - 2026-02-08 17:39 +0100
    Re: Compiler + KI "F. W." <me@home.invalid> - 2026-02-09 07:43 +0100

#656293 — Compiler + KI

https://www.anthropic.com/engineering/building-c-compiler

| I've been experimenting with a new approach to supervising language
| models that we’re calling "agent teams."
|
| With agent teams, multiple Claude instances work in parallel on a
| shared codebase without active human intervention. This approach
| dramatically expands the scope of what's achievable with LLM agents.
|
| To stress test it, I tasked 16 agents with writing a Rust-based C
| compiler, from scratch, capable of compiling the Linux kernel. Over
| nearly 2,000 Claude Code sessions and $20,000 in API costs, the agent
| team produced a 100,000-line compiler that can build Linux 6.9 on x86,
| ARM, and RISC-V.

-- 
"Es hat keine Generation gegeben, die sich nicht im exzentrischen Sinne 
"modern" fühlte und unmittelbar vor einem Abgrund zu stehen glaubte."
                      --Walter Benjamin

[toc] | [next] | [standalone]

#656327

Lars Gebauer wrote on 06.02.26 12:57:
> https://www.anthropic.com/engineering/building-c-compiler
> 
> | I've been experimenting with a new approach to supervising language
> | models that we’re calling "agent teams."
> |
> | With agent teams, multiple Claude instances work in parallel on a
> | shared codebase without active human intervention. This approach
> | dramatically expands the scope of what's achievable with LLM agents.
> |
> | To stress test it, I tasked 16 agents with writing a Rust-based C
> | compiler, from scratch, capable of compiling the Linux kernel. Over
> | nearly 2,000 Claude Code sessions and $20,000 in API costs, the agent
> | team produced a 100,000-line compiler that can build Linux 6.9 on x86,
> | ARM, and RISC-V.

Ich hatte mal ein SIMULA-67-Programm geschrieben, das Wesen simulierte,
die sich um verschiedene Arten von Leckerbissen stritten (von sättigend
bis nicht so wohlschmeckend). Idee war: ob sich eine rudimentäre Sprache
entwickelt. Heutzutage ist so ein Projekt vielleicht sogar realistisch.

[toc] | [prev] | [next] | [standalone]

#656469

On 2/6/26 12:57, Lars Gebauer wrote:
> https://www.anthropic.com/engineering/building-c-compiler
> 
> | I've been experimenting with a new approach to supervising language
> | models that we’re calling "agent teams."
> |
> | With agent teams, multiple Claude instances work in parallel on a
> | shared codebase without active human intervention. This approach
> | dramatically expands the scope of what's achievable with LLM agents.
> |
> | To stress test it, I tasked 16 agents with writing a Rust-based C
> | compiler, from scratch, capable of compiling the Linux kernel. Over
> | nearly 2,000 Claude Code sessions and $20,000 in API costs, the agent
> | team produced a 100,000-line compiler that can build Linux 6.9 on x86,
> | ARM, and RISC-V.

Ja, ruft aber immer noch hier und dort gcc auf... Und ohne Rückgriff auf 
gcc hätte das gar nicht geklappt.

  Gerrit

[toc] | [prev] | [next] | [standalone]

#656493

Gerrit Heitsch <gerrit@laosinh.s.bawue.de> wrote:
> > | To stress test it, I tasked 16 agents with writing a Rust-based C
> > | compiler, from scratch, capable of compiling the Linux kernel.
> > | Over nearly 2,000 Claude Code sessions and $20,000 in API costs,
> > | the agent team produced a 100,000-line compiler that can build
> > | Linux 6.9 on x86, ARM, and RISC-V.  
> 
> Ja, ruft aber immer noch hier und dort gcc auf... Und ohne Rückgriff
> auf gcc hätte das gar nicht geklappt.

Made my day.

-- 
Denkst Du noch, oder promptest Du schon?

[toc] | [prev] | [next] | [standalone]

#656496

Am 08.02.2026 um 09:41 schrieb Gerrit Heitsch:
> On 2/6/26 12:57, Lars Gebauer wrote:
>> https://www.anthropic.com/engineering/building-c-compiler

>> | To stress test it, I tasked 16 agents with writing a Rust-based C
>> | compiler, from scratch, capable of compiling the Linux kernel. Over
>> | nearly 2,000 Claude Code sessions and $20,000 in API costs, the agent
>> | team produced a 100,000-line compiler that can build Linux 6.9 on x86,
>> | ARM, and RISC-V.
> 
> Ja, ruft aber immer noch hier und dort gcc auf... Und ohne Rückgriff auf 
> gcc hätte das gar nicht geklappt.

Noch eine Money Quote:
"The generated code is not very efficient. Even with all
 optimizations enabled, it outputs less efficient code
 than GCC with all optimizations disabled."


Hendrik vdH

[toc] | [prev] | [next] | [standalone]

#656499

Hendrik van der Heijden <hvdh@gmx.de> wrote:

> Am 08.02.2026 um 09:41 schrieb Gerrit Heitsch:
> > On 2/6/26 12:57, Lars Gebauer wrote:  
> >> https://www.anthropic.com/engineering/building-c-compiler  
> 
> >> | To stress test it, I tasked 16 agents with writing a Rust-based C
> >> | compiler, from scratch, capable of compiling the Linux kernel.
> >> | Over nearly 2,000 Claude Code sessions and $20,000 in API costs,
> >> | the agent team produced a 100,000-line compiler that can build
> >> | Linux 6.9 on x86, ARM, and RISC-V.  
> > 
> > Ja, ruft aber immer noch hier und dort gcc auf... Und ohne
> > Rückgriff auf gcc hätte das gar nicht geklappt.  
> 
> Noch eine Money Quote:
> "The generated code is not very efficient. Even with all
>  optimizations enabled, it outputs less efficient code
>  than GCC with all optimizations disabled."

Hey, Du musst Geduld haben. In der nächsten, aber allerspätestens in
der übernächsten Version kann das LLM das alles!!111

Achja. Wir brauchen noch 23 AKWs, um das zu betreiben, aber das muss man
hinnehmen11!!!

(Und wie man in der ger.ct-Akademie lernen kann ist Atomkraft ganz arg
sicher, total billig und viel, viel, viel besser als regenerative
Energie.)

-- 
Denkst Du noch, oder promptest Du schon?

[toc] | [prev] | [next] | [standalone]

#656526

Am 06.02.26 um 12:57 schrieb Lars Gebauer:

> https://www.anthropic.com/engineering/building-c-compiler

Es gab früher auch schon compiler Generatoren
( compiler-compiler )
Die waren nach dem, was ich mitbekommen habe,
größer als die compiler selber.

-- 
<http://www.hermann-riemann.de> bzw.:
<https://www.hermann-riemann.eu/de>

[toc] | [prev] | [next] | [standalone]

#656535

Hermann Riemann <nospam.ng@hermann-riemann.de> wrote:

> Am 06.02.26 um 12:57 schrieb Lars Gebauer:
> 
> > https://www.anthropic.com/engineering/building-c-compiler  
> 
> Es gab früher auch schon compiler Generatoren
> ( compiler-compiler )
> Die waren nach dem, was ich mitbekommen habe,
> größer als die compiler selber.

Du denkst doch nicht wirklich, dass jemand wie Lars schon mal von lex
und yacc gehört hat, oder?

-- 
Denkst Du noch, oder promptest Du schon?

[toc] | [prev] | [next] | [standalone]

#656552

Am 08.02.26 um 15:04 schrieb Hermann Riemann:
> Am 06.02.26 um 12:57 schrieb Lars Gebauer:
> 
>> https://www.anthropic.com/engineering/building-c-compiler
> 
> Es gab früher auch schon compiler Generatoren
> ( compiler-compiler )
> Die waren nach dem, was ich mitbekommen habe,
> größer als die compiler selber.

Na ja. Compiler-compiler klingt doller als es war.
Meist waren das eher Parser-Generatoren.

Ein Beispiel ist der yacc (yet another compiler compiler)
der bei Unix V6 dabei war. Der Rechtsnachfolger unter
Linux ist der bison. Die Innereien des yacc sind für eine
Person noch kurzfristig zu verstehen.

Man muss eine Routine yylex() erstellen, die die lexikalische
Analyse macht und die dann Tokens liefert wie ZAHL, IDENTIFIER,
SYM_PLUS, SYM_MAL, SYM_BEGIN, SYM_KLAMMER_AUF usw.

Dann kann man die gewünschte Grammatik hinschreiben in einer
Art angereicherten BNF, etwa für einen Ausdruck

expression = ZAHL                                = { $$ = $1 }
            | IDENTIFIER                          = { $$ = $1 }
            | expression SYM_PLUS expression      = { $$ = $1 + $3 }
            | expression SYM_MAL  expression      = { $$ = $1 * $3 }
            | SYM_KLAMMER_AUF expression SYM_KLAMMER_ZU  = { $$ = $2 }
            ;
Dieses Stückchen kann dann schon Ausdrücke wie 5 * (4711 + huhu)
erkennen und den code erzeugen der das abarbeitet wenn's erkannt wird.

Die Anreicherung in der rechten Zeilenhälfte mit den vielen $$$
sagt dann was jeweils zu tun ist.

Ich habe $DAMALS einen Cross-Assembler für den Z8000 geschrieben,
das ging ratz-fatz; schon gerade im Vergleich zu ELAN (educational
language), einer Art Algol-68 für Geschwätzige.

Ein Kommandointerpreter für ein Messgerät mit GPIB/IEEE488-Interface
war auch ein Klacks.

CDL-2 von Prof. Koster ging auch grob in diese Richtung.


Gruß, Gerhard

[toc] | [prev] | [next] | [standalone]

#656605

Am 06.02.2026 um 12:57 schrieb Lars Gebauer:

> | I've been experimenting with a new approach to supervising language
> | models that we’re calling "agent teams."

Wäre die Entwicklung einer neuen, einfachen und vollständigen 
Programmiersprache nicht die bessere Idee für die $20.000 gewesen?

C-Compiler sind doch "ausentwickelt". Programmierung im herkömmlichen 
Sinne ("Wir entwerfen ein Programm und schreiben das") ist doch schon 
fast überholt. Selbst die KI programmiert sich am effizientesten schon 
selbst (Claude).

FW

[toc] | [prev] | [standalone]

Back to top | Article view | ger.ct

csiph-web