Recent posts

#1
Besides Jeff Daniels, another alias used was Tim Robbins (Bob Zale?). There was also Jim Bailey, that must be the Jim mentioned in the email, and Steve Rossell (the one that used the alias of Jeff Daniels?).
#2
After many years in which i have kept this a secret, i want to share this old part of Powerbasic history with you all - who have already been here at that time.

This person has always been "the good spirit" inside PB.
He tried to heal the open wounds that were always there, often from too much drinking ... but knowing he is unable to close them.

Sometimes you might know more then you can say. There might be more. You guessed it.
But if you can't talk about it - its te same as if you do not know it.

2026-10-11 18_20_46-Personal Messages Index - Page 3 — Mozilla Firefox.png
#3
PBXB64 - New Referenzpages

To read these go here, and click on the Frontend:

References


Here is the BASIC Reference-Page:

PBXB64 BASIC-Referenz-Pages

2026-10-11 18_17_45-Supported commands and functions _ PBXB64 V23 — Mozilla Firefox.png
#4
The Editor should be really good now and also work with Single-Step and Debugging with all compilers.
Anybody tried that?
I liked the simplicity of the PB-Editor, but we also need to see the generated ASM-Code and we might need to use AI.
And the Editor alloows that.
#5
I like the old System. YOU BUY and YOU OWN.
I don't like the "You pay and you own nothing"" system.
We will see it fail as fast as SaaS came up it wil hopefully die.
#6
There are pros and cons.
One trend we see is those charging excessive fees must lower their fees because others can offer a similar service at a lot lower price. Excessive fees must be reconsidered; the excessive fee is an incentive for some to use AI to duplicate the service. If the fee isn't excessive then there's no incentive because it would cost more to duplicate the service.
Nothing new. AI just accelerates the game because with AI few can do what it would have taken a big operation to do.
Binary hacking is illegal but similar service isn't. An exact copy is questionable.
If it's offered for free, it probably has a limited lifespan. Zillions of outdated projects all over the place.
Open source is a bit of an illusion; there are some contributing for free. You can use AI to follow the money trail and look up the salaries of those sitting on various boards and see where the money goes. It's a long trail and little trickles down to the actual project.
#7
🚀 PBX-Compiler Distribution V9 – Editor, Debugger und Compiler im gemeinsamen Paket

Entwurf / Veröffentlichungsvorlage – Stand 10. Oktober 2026
V9 ist als lokales, signiertes Paket vorbereitet. Ein V9-Webdownload ist noch nicht veröffentlicht. PBXB64 enthält den erfolgreich gebauten aktuellen Integrationsstand; Funktionstests wurden auf ausdrücklichen Nutzerwunsch nicht ausgeführt. Die neuesten bereits verfügbaren Hilfen bleiben enthalten und werden bei älterem Stand entsprechend gekennzeichnet.

📦 Welche Versionen sind für V9 vorbereitet?
  • PBX-Editor 0.3.0.27 – der gemeinsame Editor für die Compiler-Familie.
  • PBXA32 V25, 1.9.0.0 – der ausgewählte native 32-Bit-Compiler.
  • PBXA64 0.74.0-V74 – der ausgewählte native x64-Compiler.
  • PBXC64 1.0.0-rc50 – ein aktualisierter Compiler aus dem Entwicklungszweig mit Quellzeilentabellen.
  • PBXB64 23.0.0-V23 – erfolgreich gebauter kombinierter Integrationsstand vom 10. Oktober, mit neu eingebetteten Runtime-Payloads und aktuellen C17-Headern.
  • ScharffBASIC – unverändert aus V8 übernommen.
Die Paketnummer V9 und die Versionsnummern der einzelnen Programme sind voneinander unabhängig. Ein Compiler muss deshalb nicht ebenfalls ,,V9" heißen.

🧩 Der Editor merkt sich den Compiler jeder Datei
Eine wichtige Verbesserung in 0.3.0.27 betrifft Projekte mit mehreren Compiler-Dialekten: Jeder Tab behält seine eigene Compiler-Auswahl. Wer eine ScharffBASIC-Datei und eine PBXB64-Datei gleichzeitig bearbeitet, kann zwischen beiden wechseln, ohne jedes Mal den Compiler erneut einzustellen.

Beim Tabwechsel folgen Werkzeugleiste, Fenstertitel, Menüauswahl und Statusanzeige dem Compiler des Tabs. Die Syntaxdarstellung und die Schlüsselwortlisten richten sich ebenfalls nach dieser Zuordnung. Eine ausdrücklich gewählte Compiler-Einstellung hat Vorrang; ,,Speichern unter" mit einer anderen Dateiendung kann die Zuordnung neu bestimmen. Auch beim Wiederherstellen von Sitzungen wird die Auswahl berücksichtigt.

Mehr Übersicht im Alltag:
  • Die Werkzeugleiste zeigt die vollständigen Compiler-Namen und behält beim Umschalten ihre Höhe.
  • Der Ausgabebereich besitzt einen sichtbaren Rahmen und lässt sich leichter vom Quelltext unterscheiden.
  • Die Breite des Projektbaums wird gespeichert.
  • Der Datei-Finder zeigt neben dem Dateinamen den relativen Ordner. Gleichnamige Dateien in verschiedenen Unterverzeichnissen lassen sich dadurch besser unterscheiden.
  • Datei-Finder, Symbolsuche, inkrementelle Suche und Aufzeichnungsdialog passen sich an die dunkle Darstellung an; deaktivierte Checkboxen werden deutlicher abgesetzt.

✍️ B64, Einrückung und Navigation
Der Editor behandelt .b64 jetzt ausdrücklich als die eigene Sprache B64 mit geschweiften Klammern, fn und struct. Dazu gehören eigene Schlüsselwort- und Typenlisten, Vervollständigungen, Snippets, Klammer-Faltung und die passende B64-Anzeige in der Statusleiste. ,,Kommentar umschalten" verwendet dort //. Die Darstellung verwendet die C-Lexer-Technik, die Sprache bleibt B64. FreeBASIC-Dateien haben ihre eigenen Zuordnungen, unter anderem .fb und .bi.

Die intelligente Einrückung unterstützt sowohl BASIC-Blöcke als auch die Klammer-Sprachen C/C++, B64 und Rust. Nach einem BASIC-Blockanfang wird die nächste Zeile eingerückt; Abschlusszeilen und ELSE/ELSEIF werden an der Blockstruktur ausgerichtet. Bei Klammern kann Enter zwischen { und } eine eingerückte Leerzeile erzeugen. Kommentare und mehrzeilige Konstruktionen werden gesondert berücksichtigt.

Format Document und Format Selection ordnen die führenden Leerzeichen neu; der Formatierungsvorgang lässt sich als ein Schritt rückgängig machen. Für die Suche im Quelltext stehen außerdem ,,Go to Line", ,,Go to Symbol" und der Datei-Finder zur Verfügung. F12 sucht BASIC-Definitionen in der aktuellen Datei; Alt+Links und Alt+Rechts führen durch die Navigationshistorie. F12 ist keine projektweite Symbolauflösung für alle Sprachen.

F1 öffnet die Hilfe des aktiven Compilers; Shift+F1 öffnet die Editor-Hilfe. So bleiben Sprachreferenz und Bedienung des Editors direkt erreichbar.

🐞 Debugging: Quelltext, Haltepunkte und Einzelschritte
Im vorbereiteten Editor 0.3.0.27 ist das Quelltext-Debugging für PBXB64 und ScharffBASIC freigeschaltet. Voraussetzung ist ein passend erzeugtes Programm mit Debug-Informationen. Die Erweiterung auf die übrigen Compiler gehört zu späteren Editor-Arbeiten und ist in dieser EXE noch nicht freigeschaltet.

,,Compile & Debug" erstellt einen Debug-Build ohne Optimierung und startet das Programm unter dem integrierten Debugger. Die aktuelle Quellzeile wird markiert; Meldungen und Zustandsausgaben erscheinen im Ausgabebereich. Das erlaubt einen kurzen Weg vom beobachteten Verhalten zur verantwortlichen Codezeile.

  • Ctrl+F5: kompilieren und Debug-Sitzung starten.
  • F9: Haltepunkt setzen oder entfernen.
  • F5: bis zum nächsten Haltepunkt, zur Ausnahme oder zum Programmende fortsetzen.
  • F10: Step Over – die nächste Quellzeile ausführen und aufgerufene Routinen als Ganzes durchlaufen.
  • F11: Step Into – in aufgerufenen eigenen Code hineinsteigen.
  • Shift+F11: Step Out – bis zur Rückkehr aus der aktuellen Routine laufen.
  • Ctrl+F10: bis zur Cursorzeile laufen, sofern dort ausführbarer Code vorhanden ist.
  • Shift+F5: Debug-Sitzung beenden.
Haltepunkte sind besser nachvollziehbar: Eine leere Zeile oder Deklaration kann den Haltepunkt auf die nächste ausführbare Zeile innerhalb derselben Routine verschieben. Die Suche springt dabei nicht in eine andere SUB oder FUNCTION. Ein Haltepunkt, den das laufende Programm nicht auflösen kann, erscheint als hohler Kreis. Die Ausgabe erklärt die Verschiebung oder die fehlende Zuordnung.

Zusätzlich lassen sich der Aufrufstapel mit Routinenamen und Quellpositionen, CPU-Register, Disassembly und ein Speicherausschnitt anzeigen. Bedingte Haltepunkte arbeiten mit Register- und Zahlenvergleichen, beispielsweise rax == 5. Eine Variablen-Watch-Ansicht und Edit-and-Continue gehören nicht zu diesem Stand. Bei ScharffBASIC benötigen die Schritte die vom Compiler erzeugte .pbd-Tabelle; Zeilen ohne eigene Anweisung bleiben von der Ausführung abhängig.

🔎 Die ASM-Ansicht verbindet Quelltext und Maschinencode
Die ASM-Ansicht zeigt ein Compiler-Listing oder die Disassembly des erzeugten Programms. Mit passenden Debug-Zeilendaten lässt sich von einer Anweisung zur zugehörigen Quellzeile springen; Ctrl+Alt+A führt vom Quelltext zur ASM-Ansicht. Für ScharffBASIC wird die genaue .pbd-Anweisungstabelle zur Zuordnung verwendet. Die Anzeige erläutert auch ausgelassene oder nicht ausführbare Bereiche.

Ausgewählten Code kann man kopieren, speichern oder für die unterstützten BASIC-Dialekte als Inline-Assembler übernehmen. Dabei werden Sprungziele innerhalb des Ausschnitts in Labels umgewandelt und bestehende Labelnamen bei Bedarf ergänzt. Rückkehranweisungen und Funktions-Epiloge werden kommentiert; problematische Stack-, Daten- oder externe Sprungbezüge erhalten TODO-Hinweise. Ein eingefügter Block bleibt ein Undo-Schritt und muss vor seiner Verwendung geprüft werden. B64-Dateien sind in dieser Editor-Version kein Inline-ASM-Ziel.

⚙️ Compiler: vorbereitete Updates und laufende Integration
PBXA32 V25 enthält die Source62-Zusammenführung. Die belegten Quelländerungen betreffen unter anderem die vertauschte C-Zeigeraddition mit anschließendem Indexzugriff sowie eingebettete Aggregate in UNIONs. Ungültige Kombinationen wie Zeiger plus Zeiger und Ganzzahl minus Zeiger bleiben diagnostiziert; gleichnamige, widersprüchliche Aggregate sollen weiterhin abgewiesen werden. Diese Änderungen sind am ausgewählten Quellstand belegt. Der signierte Compiler hat außerdem einen gezielten Test bestanden, der ein kleines BASIC-Programm als natives x86-Programm erzeugt und dessen erwarteten Rückgabewert bestätigt; das ist keine vollständige Sprachqualifikation.

PBXA64 ist mit dem aktualisierten 0.74.0-V74-Artefakt vorbereitet. Der zugehörige Entwicklungszweig arbeitet an genaueren Include-Fehlerpositionen, Quellzeilentabellen und ASM-Zuordnungen. Die vollständige Zuordnung jedes späteren Quelländerungs-Commits zur ausgewählten EXE ist noch zu bestätigen; daraus entsteht hier keine pauschale Zusage für alle Änderungen.

PBXC64 rc50 stammt aus dem aktualisierten Zeilentabellen-Zweig. Dort wurden .sdbg-Debugtabellen mit Include-Dateizuordnung, Quellmarker im ASM-Listing sowie die semantische Prüfung der PBMAIN-Signatur ergänzt. Eine ungeeignete PBMAIN-Signatur soll damit bereits bei ,,syntax-only" dieselbe Diagnose erhalten wie beim Build. Diese Compiler-Arbeiten schalten das Quelltext-Stepping im älteren Editor 0.3.0.27 noch nicht automatisch frei.

🛠� PBXB64: Sprache, Semantik und verständlichere Grenzen
Die folgenden Punkte beschreiben den zugeordneten Integrationsquellstand der neuen EXE. Funktionale und native Prüfungen dieses Builds wurden auf Nutzerwunsch nicht ausgeführt; eine vollständige Sprachqualifikation wird nicht behauptet.

PBXB64 verbindet die Frontends BASIC, C, B64, PILOT, COBOL, Forth, Logo, Rust und SPR mit der gemeinsamen x64-Werkzeugkette. Die zusätzlichen Sprachen haben dokumentierte Teilmengen und Grenzen; ihre Aufnahme bedeutet keine vollständige Kompatibilität mit jeder bestehenden Implementierung.

  • B64: Strengere Diagnosen für unbekannte Escape-Sequenzen, leere Zeichenliterale und unvollständige Zeichenketten. Für kanonische i64-Operanden sind &=, |= und ^= vorgesehen; Gleitkomma- und Zeigeroperationen behalten eigene Grenzen.
  • Logo: Das Lesen eines ungebundenen eigenständigen Variablennamens wird diagnostiziert. Direkte Vergleiche zwischen Wort und Zahl erhalten klarere Typgrenzen. Die Erkennung einer Zuweisung im Quelltext ist dabei keine Garantie für deren Ausführung vor dem Lesen.
  • Forth: Überarbeitung von KEY und COUNT für Bytewerte, eindeutige Diagnose übergroßer gezählter Zeichenketten und präzisere Grenzen bei Fließkommawerten über Kontrollfluss-Verzweigungen.
  • Rust: Arbeit an Option/Result-Wertübergaben, zip-Tupelzuordnung, Trait-Objektzuweisungen sowie Diagnosen für ungültige Divisionen, Schiebeoperationen und übertiefe Parser-Rekursion. Der implementierte Rust-Dialekt bleibt eine Teilmenge mit eigenen dokumentierten Erweiterungen.
  • COBOL: Überarbeitung der Übergabebeschreibungen für native Aufrufe, Schutz bei überlappenden NATIONAL-MOVE-Bereichen und Prüfung skalierter Division. Dazu kommen begrenzte Speicherverwaltung und explizite Diagnosen für ungültige Adressen und Schema-Grenzen.
  • BASIC / RATIONAL: Der Integrationsquellstand erweitert skalare RATIONAL-Parameter und Rückgabewerte sowie MOD und Potenzen. Daraus folgt keine Zusage für eine universelle externe ABI oder unbegrenzte exakte Arithmetik.
  • Inline-ASM-Listings: Separat assemblierte Blöcke werden mit Quellzeilenmarkern und kommentierten Anweisungen sichtbar, statt nur einen Aufruf des erzeugten Hilfsblocks zu zeigen.
Ressourcen brauchen klare Grenzen: Der Integrationsquellstand bietet --memory-budget-mib=N mit standardmäßig 1024 MiB für erfasste compiler-eigene Allokationen. Bei Überschreitung wird ein Fehler gemeldet. Das ist keine Obergrenze für den gesamten Windows-Prozessspeicher und begrenzt nicht den Speicher eines später ausgeführten Anwenderprogramms. Hinzu kommen Teilmengengrenzen wie 256 Ebenen für bewachte Rust-Parser-Verschachtelung und eine COBOL-Allokationsverwaltung mit 1024 Einträgen. Der später entwickelte allgemeine Speicherstopp des Editors ist in 0.3.0.27 noch nicht enthalten.

🤖 MiniRobot / SPR: der Umfang dieses Schritts
Für den Abschluss der V9-Integration ist der SPR-Umfang auf 73 bereits begonnene Befehle eingefroren: 13 A-, 19 B- und 41 C-Befehle. Die laufenden Arbeiten schließen deren Runtime-Anbindung und bekannte Vertragsfehler ab. Die Zahl beschreibt den gewählten Arbeitsumfang; sie ist keine Behauptung, dass bereits 73 Befehle im finalen Paket vollständig getestet sind.

SPR Browser ist verschoben. Zusätzliche Befehlsfamilien und weitere Erweiterungen folgen im nächsten Release. Aus der Quellintegration allein lässt sich weder die vollständige SPR-Sprache noch die Wirksamkeit sämtlicher GUI- und Automationsaktionen ableiten.

📚 Hilfe, Beispiele und Download
V9 übernimmt die gemeinsame Paketstruktur mit Editor, Compiler-Verzeichnissen, Includes, Beispielen und CHM-Hilfen. Die Editor-Hilfe wurde aktualisiert. Die neuesten verfügbaren PBXB64-Hilfen stammen vom 5. Oktober und sind für die neue Integration nicht frisch erzeugt. Auch die übrigen Compiler behalten ihre zuletzt verfügbaren CHMs; PBXA32 hat keine gesonderte V25-Hilfe. Pauschale neue Beispiel- oder Testzahlen werden nicht angegeben.

Aktuelle Download-Übersicht und Beschreibung:
📥 PBX-Compiler-Paket – deutsche Download-Übersicht
🌍 PBX-Compiler-Paket – English download overview

Diese überprüften Seiten bieten derzeit V8 / PBX-Basic_08.zip an. V9 ist dort jetzt verfügbar.

Alle sechs enthaltenen EXEs besitzen gültige Signaturen mit Zeitstempel. Editor sowie PBXA32, PBXA64, PBXB64 und PBXC64 bestehen die UPX-Integritätsprüfung. ScharffBASIC samt Hilfe bleibt auf ausdrücklichen Nutzerwunsch bytegleich V8; seine gültig signierte EXE ist die dokumentierte Ausnahme von UPX. Die Paketprüfung bestätigt Dateiherkunft und Archivgleichheit, keine vollständige Compilerqualifikation.

💬 Rückmeldungen helfen beim Einordnen: Bitte nennt bei einem Fehler den Compiler mit Versionsnummer, die verwendeten Schalter, die genaue Meldung und möglichst ein kleines Quellbeispiel. Bei Debugger-Fragen sind außerdem Editor-Version und der verwendete Debug-Build hilfreich.
#8
🚀 PBX-Compiler Distribution V9 – Editor, Debugger and Compilers in One Package

Draft / publication template – 10 October 2026
V9 is prepared as a local signed package. A V9 web download has not been published. PBXB64 contains the successfully built current integration; functional tests were not run under explicit user instruction. The latest already available help artifacts are included, with older help clearly identified.

📦 Versions prepared for V9
  • PBX-Editor 0.3.0.27 – the shared editor for the compiler family.
  • PBXA32 V25, 1.9.0.0 – the selected native 32-bit compiler.
  • PBXA64 0.74.0-V74 – the selected native x64 compiler.
  • PBXC64 1.0.0-rc50 – an updated compiler from the source-line-table development branch.
  • PBXB64 23.0.0-V23 – successfully built combined integration from 10 October, with freshly embedded runtime payloads and current C17 headers.
  • ScharffBASIC – retained unchanged from V8.
Distribution V9 and the individual program versions use separate numbering. The compilers do not all have to be called "V9".

🧩 Each editor tab remembers its compiler
A useful improvement in 0.3.0.27 concerns projects that contain several compiler dialects: each tab retains its own compiler selection. You can keep a ScharffBASIC source and a PBXB64 source open together and switch between them without selecting the compiler again each time.

The toolbar, window title, menu selection and status display follow the active tab. Syntax colouring and keyword lists also follow that tab's compiler. An explicit compiler choice takes precedence; saving under a different file extension can select a new association. Session restoration takes the saved selection into account.

Everyday usability improvements:
  • The toolbar displays full compiler names and retains its height when switching compilers.
  • The output pane has a visible frame, making it easier to distinguish from the source editor.
  • The project tree retains its width.
  • The file finder shows the relative folder beside each filename, helping distinguish files with identical names in different directories.
  • The file finder, symbol finder, incremental search and recording dialogs adopt the dark appearance; disabled checkboxes are easier to distinguish.

✍️ B64 editing, indentation and navigation
The editor explicitly treats .b64 as the B64 language with braces, fn and struct. It provides B64 keyword and type lists, completion words, snippets, brace folding and the B64 status label. Toggle Comment uses //. The highlighting uses the C lexer machinery while retaining B64's own language rules. FreeBASIC has its own associations, including .fb and .bi.

Smart indentation covers BASIC blocks and the brace languages C/C++, B64 and Rust. A BASIC block opener indents the next line; closing statements and ELSE/ELSEIF align with the relevant block. Enter between { and } can create an indented empty line. Comments and multiline constructs receive separate handling.

Format Document and Format Selection adjust leading whitespace, and the operation can be undone in one step. Navigation includes Go to Line, Go to Symbol and the file finder. F12 finds BASIC definitions in the current file; Alt+Left and Alt+Right move through navigation history. F12 does not provide project-wide symbol resolution for every language.

F1 opens the active compiler's help; Shift+F1 opens Editor Help. This keeps language reference and editor instructions close to the code you are working on.

🐞 Source debugging, breakpoints and single stepping
The prepared Editor 0.3.0.27 enables source debugging for PBXB64 and ScharffBASIC. It requires a program built with suitable debug information. Support for the other compilers belongs to later editor work and is not enabled in this executable.

Compile & Debug builds without optimization and launches the program under the integrated debugger. The current source line is marked in the editor, while messages and state displays appear in the output pane. This provides a direct route from observed behaviour to the source statement responsible for it.

  • Ctrl+F5: compile and start a debug session.
  • F9: set or remove a breakpoint.
  • F5: continue to the next breakpoint, exception or program exit.
  • F10: Step Over – execute the next source line and run called routines as a whole.
  • F11: Step Into – enter calls into your own code.
  • Shift+F11: Step Out – run until the current routine returns.
  • Ctrl+F10: run to the cursor line if it contains executable code.
  • Shift+F5: stop the debug session.
Breakpoint placement is easier to understand: A blank line or declaration can move a breakpoint to the next executable line within the same routine. The search does not jump into another SUB or FUNCTION. A breakpoint that the running program cannot resolve appears as a hollow circle. The output explains relocation or missing code mappings.

You can also display the call stack with routine names and source positions, CPU registers, disassembly and a memory excerpt. Conditional breakpoints compare registers and numbers, for example rax == 5. This version has no variable watch view or edit-and-continue. ScharffBASIC stepping uses the compiler-generated .pbd statement table; lines without their own executable statement follow the underlying execution model.

🔎 ASM View links source code with machine instructions
ASM View displays a compiler listing or disassembly of the generated program. With suitable debug line information, you can jump from an instruction to its source line; Ctrl+Alt+A takes you from the source to ASM View. ScharffBASIC mappings use the exact .pbd statement table. The display also explains omitted or non-executable regions.

Selected code can be copied, saved or converted to inline assembly for the supported BASIC dialects. Jump targets inside the selection become labels, with suffixes added when existing names would collide. Return instructions and function epilogues are commented; stack operands, data references and external jump dependencies receive TODO notes. An inserted block is one undo operation and needs review before use. B64 files are not inline-assembly insertion targets in this editor version.

⚙️ Prepared compiler updates and ongoing integration
PBXA32 V25 includes the Source62 composition. Source-backed changes address commuted C pointer addition followed by indexing and embedded aggregates in UNIONs. Invalid pointer-plus-pointer and integer-minus-pointer combinations remain diagnosed; conflicting aggregate names retain rejection rules. These changes are evidenced in the selected source snapshot. The exact signed compiler also passed a targeted check that builds a small BASIC program as a native x86 executable and confirms its expected return value. That check is not full language qualification.

PBXA64 is prepared with the updated 0.74.0-V74 artifact. Its development branch contains work on include-aware diagnostic positions, source-line tables and assembly mappings. The complete mapping of every later source-change commit to the selected executable still needs confirmation, so this post makes no blanket promise about all those changes.

PBXC64 rc50 comes from the updated line-table branch. That branch adds .sdbg debug tables with included-file mappings, source markers in assembly listings and semantic PBMAIN signature checks. An unsuitable PBMAIN signature should therefore receive the same diagnostic in syntax-only mode as during a build. These compiler changes do not automatically enable source stepping in the older Editor 0.3.0.27.

🛠� PBXB64: language semantics, diagnostics and explicit limits
The following items describe the integration source bound to the new executable. Functional and native checks of this build were not run under user instruction; full language qualification is not asserted.

PBXB64 connects the BASIC, C, B64, PILOT, COBOL, Forth, Logo, Rust and SPR frontends to a shared x64 toolchain. The additional languages have documented subsets and limits; their inclusion does not establish complete compatibility with every existing implementation.

  • B64: Stricter diagnostics for unknown escapes, empty character literals and incomplete strings. Canonical i64 operands admit &=, |= and ^=; floating-point and pointer operations retain separate limits.
  • Logo: Reading an unbound standalone variable name is diagnosed. Direct word/number comparisons have clearer type boundaries. Detecting an assignment in the source does not guarantee that it executes before a read.
  • Forth: KEY and COUNT byte handling is revised, oversized counted strings receive explicit diagnostics, and floating-point values across control-flow merges have clearer restrictions.
  • Rust: Work covers Option/Result payload transfers, zip tuple layout, trait-object assignment and diagnostics for invalid division, shifts and excessive parser recursion. The implemented Rust dialect remains a subset with its own documented extensions.
  • COBOL: Native-call descriptors, overlapping NATIONAL MOVE handling and scaled division checks are being corrected. Bounded allocation tracking and explicit invalid-address and schema-limit diagnostics are also included in the source work.
  • BASIC / RATIONAL: The integration source extends scalar RATIONAL parameters and results, MOD and exponentiation. This does not establish a universal external ABI or unlimited exact arithmetic.
  • Inline-assembly listings: Separately assembled blocks become visible through source-line markers and commented instructions, rather than only a call to the generated helper block.
Resources need explicit limits: The integration source provides --memory-budget-mib=N, defaulting to 1024 MiB for tracked compiler-owned allocations. Exceeding the budget reports an error. This is not a cap on the entire Windows process memory footprint and does not limit a subsequently executed user program. Other subset limits include 256 levels for guarded Rust parser nesting and a COBOL allocation tracker with 1024 entries. The later general editor memory-stop mechanism is not present in 0.3.0.27.

🤖 MiniRobot / SPR: scope of this integration step
SPR work for the V9 integration is frozen to 73 commands already started: 13 A commands, 19 B commands and 41 C commands. Ongoing work completes their runtime connections and known contract corrections. This number describes the selected work scope; it does not claim that 73 commands have already passed complete tests in a final package.

SPR Browser is deferred. Additional command families and further extensions belong to the next release. Source integration alone does not establish full SPR language support or the live effects of every GUI and automation action.

📚 Help, examples and downloads
V9 retains the shared package layout with the editor, compiler directories, includes, examples and CHM help. Editor Help has been updated. The latest available PBXB64 help dates from 5 October and was not regenerated for the new integration. Other compilers retain their latest already available CHMs; PBXA32 has no distinct V25 help. No blanket new example counts or test totals are asserted.

Current download overview and product description:
📥 PBX-Compiler package – English download overview
🌍 PBX-Compiler package – German download overview

These verified pages currently offer V8 / PBX-Basic_08.zip. V9 is now available there.

All six included EXEs have valid timestamped signatures. Editor and PBXA32, PBXA64, PBXB64 and PBXC64 pass UPX integrity checks. ScharffBASIC and its help remain byte-identical to V8 under explicit user instruction; its signed EXE is the documented UPX exception. Package verification establishes provenance and archive equality, not full compiler qualification.

💬 Useful feedback: Please include the compiler and version, command-line switches, exact diagnostic and a small reproducing source whenever possible. For debugger questions, also include the editor version and the debug build used.
#9
Thanks for the offer. I'm not going to write a compiler, too many details.
This was the result of asking DeepSeek if it was possible to write a BASIC compiler that translates to C, that automatically frees the strings. That can be done using GCC or Clang and "__attribute__((cleanup))." It offered to write a sample, so why not.
That can be used in C for the same purpose, but you must handle the details.

It's one thing to write a compiler that can do some things. It's another thing to try and build a complete congruent package.

I asked DeepSeek about this crazy ideal I had about a compiler. A procedure can't return a value. Nothing in the wild. Everything is passed down and freed when it unwinds. 100% memory safe. DeepSeek said it wasn't crazy. In a complex way, that's what Rust does. It allows returns but implements something like that under the hood.

I see OPP, COM, C++ and maybe Rust, as complex solutions to problems that in the end may cause more problems due to complexity than the original problem.
#10
It's not just one person, but a team of programmers. There are always small teams, each of which continues to develop one of the products originally created by Adobe. So the entire team is quite large. The biggest problem, however, lies with organizations like the World Economic Forum, whose dream has always been: "You will own nothing, but you will be happy." Now we're seeing that you don't even have to own anything anymore—especially when it comes to software. Most things will be free, and the barrier to entry for paid software is getting higher and higher.

#OpenSource #SoftwareDevelopment #AdobeAlternatives #Digitalization #WorldEconomicForum

Das ist nicht nur eine Person, sondern ein Team von Programmierern. Es gibt immer kleine Teams, die jeweils eines der ursprünglich von Adobe stammenden Produkte weiterentwickeln. Das gesamte Team ist also ziemlich groß. Das größte Problem haben jedoch Organisationen wie das Weltwirtschaftsforum, deren Traum es immer war: ,,Du wirst nichts besitzen, aber glücklich sein." Jetzt sehen wir, dass man nicht einmal mehr etwas besitzen muss – vor allem bei Software. Die meisten Dinge werden kostenlos sein, und die Hürde für kostenpflichtige Software wird immer höher.

#OpenSource #SoftwareEntwicklung #AdobeAlternativen #Digitalisierung #Weltwirtschaftsforum