Besides researching aspects of Ruby, I have taken my old Pascal books to find out how Wirth programs look like in both direct Ruby translations and idiomatic Ruby. Also working with available Ruby insruction material.

Am a retired electric power engineer who never programmed for work. Took up Turbo Pascal as a hobby, but stopped because of family responsibilities and continual employment changes.

I am finding Perplexity user friendly and useful in my endeavors.

After weeks of inactivity, I'm back with updates!

* Case-sensitive input for Question()

* Implemented some more cursor (as in terminals) functions

* Properly print escape sequences to the right outout (stdout or stderr - before was only stdout)

* Implemented color resetting for Win32 console (doesn't work though)

* Fixed the console example not printing anything readable

* Added some well-known sorting algorithms

Test and let me know your thoughts!

Hi everyone!

I've worked with Delphi for many years. Recently, I developed three IDE plugins to solve some everyday frustrations. All three are free, open source (MIT license), and support Delphi 11, 12 and 13, including the 64-bit IDE in Delphi 12 and 13.

To install, download the release ZIP, extract it, and run Install.bat. No administrator rights or compiler required.

1. CS.Coder Project Hub (Stable)

A project organizer built into the Delphi Welcome Page. It lets you:

• Group project shortcuts by client, system, or any category you choose.
• Add icons, search by name or path, and organize entries using drag and drop.
• Export and import the shortcut list as JSON.

It works alongside Delphi's Open Recent panel without changing it. It never moves or deletes project files; it manages shortcuts only.

GitHub: https://github.com/cscoder69/delphi-project-hub

2. CS.Coder Unit Styler (Beta)

A configurable formatter for uses clauses. You can choose one unit per line or multiple units per line, sorting, indentation, priorities, and groups such as System.*.

• Run it on the current unit, open units, or an entire project.
• Preview the before/after result and confirm before applying changes.
• Back up each file before modifying it.

Because unit order can matter, library namespaces (Winapi.*, System.*, Vcl.*, FMX.*, Data.*) are protected from reordering by default. The formatter is designed to preserve comments, compiler directives, encoding, and line endings.

GitHub: https://github.com/cscoder69/delphi-unit-styler

3. CS.Coder Block Folding (Beta)

Adds folding for blocks inside routines, beyond Delphi's built-in routine, class, and region folding.

Supported structures include if/else, for, while, with, try, case, repeat, and standalone begin..end blocks.

Press Ctrl+Alt+B to fold or expand the block at the cursor. It doesn't insert {$REGION} directives or modify your source. Folds exist only in the editor while the unit is open.

Current limitation: its menu and settings are available in Portuguese only.

GitHub: https://github.com/cscoder69/delphi-block-folding

Documentation (Portuguese)

• Project Hub: https://www.cscoder.com.br/projetos/hub-de-projetos-delphi/
• Unit Styler: https://www.cscoder.com.br/projetos/unit-styler-delphi/
• Block Folding: https://www.cscoder.com.br/projetos/block-folding-delphi/

A few important notes

• Unit Styler and Block Folding are in beta. Please use version control when testing tools that interact with source code.
• No telemetry, network access, or account. Settings are stored locally.
• Claude Code helped extensively with implementation. I defined the requirements, made the design decisions, and tested the plugins inside the Delphi IDE. The source is available for review.
• These projects are independent and are not affiliated with Embarcadero.

Feedback, bug reports, and suggestions are welcome. If something doesn't work in your setup, please open an issue in the relevant GitHub repository and include your Delphi version and IDE architecture.

Thanks for reading!

Hi everyone!

I've worked with Delphi for many years. Recently, I developed three IDE plugins to solve some everyday frustrations. All three are free, open source (MIT license), and support Delphi 11, 12 and 13, including the 64-bit IDE in Delphi 12 and 13.

To install, download the release ZIP, extract it, and run Install.bat. No administrator rights or compiler required.

1. CS.Coder Project Hub (Stable)

A project organizer built into the Delphi Welcome Page. It lets you:

• Group project shortcuts by client, system, or any category you choose.
• Add icons, search by name or path, and organize entries using drag and drop.
• Export and import the shortcut list as JSON.

It works alongside Delphi's Open Recent panel without changing it. It never moves or deletes project files; it manages shortcuts only.

GitHub: https://github.com/cscoder69/delphi-project-hub

2. CS.Coder Unit Styler (Beta)

A configurable formatter for uses clauses. You can choose one unit per line or multiple units per line, sorting, indentation, priorities, and groups such as System.*.

• Run it on the current unit, open units, or an entire project.
• Preview the before/after result and confirm before applying changes.
• Back up each file before modifying it.

Because unit order can matter, library namespaces (Winapi.*, System.*, Vcl.*, FMX.*, Data.*) are protected from reordering by default. The formatter is designed to preserve comments, compiler directives, encoding, and line endings.

GitHub: https://github.com/cscoder69/delphi-unit-styler

3. CS.Coder Block Folding (Beta)

Adds folding for blocks inside routines, beyond Delphi's built-in routine, class, and region folding.

Supported structures include if/else, for, while, with, try, case, repeat, and standalone begin..end blocks.

Press Ctrl+Alt+B to fold or expand the block at the cursor. It doesn't insert {$REGION} directives or modify your source. Folds exist only in the editor while the unit is open.

Current limitation: its menu and settings are available in Portuguese only.

GitHub: https://github.com/cscoder69/delphi-block-folding

Documentation (Portuguese)

• Project Hub: https://www.cscoder.com.br/projetos/hub-de-projetos-delphi/
• Unit Styler: https://www.cscoder.com.br/projetos/unit-styler-delphi/
• Block Folding: https://www.cscoder.com.br/projetos/block-folding-delphi/

A few important notes

• Unit Styler and Block Folding are in beta. Please use version control when testing tools that interact with source code.
• No telemetry, network access, or account. Settings are stored locally.
• Claude Code helped extensively with implementation. I defined the requirements, made the design decisions, and tested the plugins inside the Delphi IDE. The source is available for review.
• These projects are independent and are not affiliated with Embarcadero.

Feedback, bug reports, and suggestions are welcome. If something doesn't work in your setup, please open an issue in the relevant GitHub repository and include your Delphi version and IDE architecture.

Thanks for reading!

Pure Free Pascal 3.2.2 / GLFW3 / OpenGL3.3 / OpenAL / MiniGUI.pas / Assimp / libvlc.dll / FreeImage.dll / DOD / [NO LAZARUS BINDING]

Assimp integration is successful, but the movement of animated objects is still under development; currently, they can only be displayed statically.

Game demo featuring GLB testing:
The entire environment is procedurally generated: a sky projected onto a sphere, terrain with trees and bushes, and winding roads with lane markings. Generated textures are applied to the terrain, asphalt, and sky. Traffic interacts dynamically: faster vehicles overtake slower ones, and honking causes cars ahead of the player to accelerate briefly to avoid impeding traffic. It features procedural engine sound and functional gear shifting.

My initial goal was a texture-free 3D world, though I experimented with textures just in case. I still consider the use of textures unnecessary for a low-poly world, as I have successfully achieved visually impressive results using vertex-colored geometry. Of course, the two approaches can be combined depending on the scene's requirements.

Hey everyone! 👋

I wanted to share a passion project I’ve been working on called EXO-SCOPE.

Instead of traditional 3D graphics, I wanted to capture the claustrophobic, high-tension feeling of operating a deep-space telemetry satellite purely through abstract data and a Command Line Interface (CLI). You play as an operator searching for habitable exoplanets, filtering background radiation noise, and occasionally stumbling upon terrifying anomalies.

Here is what makes it unique:

⌨️ CLI-Driven Gameplay: You navigate the cosmos, apply Gaussian/Moving Average filters to light curves, and deploy surface probes entirely by typing terminal commands.

📺 Retro CRT Aesthetic: I built a custom rendering engine to create authentic scanlines, vignette darkening, and UI glow to make it feel like you are staring at a 90s military monitor.

🔊 Immersive Audio Design: Heavy focus on sound atmosphere—mechanical radar sweeps, rapid typewriter terminal blips, and heart-pounding alarms when you encounter encrypted alien signals (Biosignatures & Megastructures).

🌌 Procedural Starmap: A 3000x3000 explorable galaxy featuring gravitational lensing distortions if you pan your telescope too close to a Black Hole.

The Tech Stack:

I built this entirely using Free Pascal / Lazarus.

Graphics/UI: BGRABitmap for all the custom rendering, CRT effects, and Alpha Blending transitions.

Audio: BASS library for handling concurrent channels (ambience, UI feedback, and alarms).

I just open-sourced the entire project on GitHub. If you are into retro-sci-fi aesthetics, terminal games, or Pascal development, I’d be honored if you checked it out!

Link : https://github.com/CodeInPas/Exoscope

I have a completed C# project that is already published on the Microsoft Store, but I feel guilty, dirty, and sinful for using .NET. So, I’ve started migrating it to Lazarus—naturally, with the help of AI and Hermes Agent. I’ve been at it for about three days, and I think we’re 80% of the way there. There’s still testing to be done, but I feel like I’m heading in the right direction.

It’s inventory software using SQLite, with both local and server modes, and comprises 60 forms.

I've been working on a simple security research tool (https://nofuss.co.za/tools/ppee/) that runs in the browser. Since Web Assembly is already sandboxed, it makes it reasonably safe. It also doesn't try to execute the EXE or DLL, but rather just peek into it and extract some header and string information. Oh and also tries to figure out which dependencies it has and what calls it makes. So one could see that something is calling the network, or accessing the registry etc. Based on the strings, you might see it's make calls to somewhere you didn't expect.

It's not done, I am learning more and more about the PE file format, but it's already pretty useful if you know what you're looking for.

A pixel-perfect, skeuomorphic UI component library for Lazarus/FPC inspired by Dieter Rams' classic Braun designs. Features highly detailed knobs, faders, switches, LEDs, and dynamic theming to bring vintage hi-fi aesthetics to your modern applications.

https://github.com/CodeInPas/BraunUI

I know it's a long shot, but I'm trying to track down a very obscure DOS Ultima-clone game/engine with (Turbo) Pascal source code from the 1990s.

Sometime around 1990–1996, I got a shareware/freeware CD-ROM collection containing what I remember as an Ultima V clone or Ultima V-style RPG engine.

The really distinctive part: the source code was included, and I remember it being written in Turbo Pascal (with some "inline" assembly)

What I remember:

DOS - MCGA/VGA 320x200 probably (mode 13h baby!)

Top-down, very much in the style of Ultima V

It was more of an unfinished game / engine / hobby project than a commercial-quality RPG

Turbo Pascal source code was included

I have a vague memory that the author may have been Finnish.

I probably got it from some random shareware CD-ROM collection, possibly a Walnut Creek / Simtel-type collection. It may have been a copy of a foreign CD, so I can't reliably identify the original source.

I've spent years and years occasionally searching for this thing, but I've never managed to find it again.

If anyone remembers an obscure Turbo Pascal RPG/engine from the 90s that looked like Ultima V, please let me know. Even a filename, author name, CD-ROM title, old BBS post, archive listing, or screenshot could be enough to identify it.

I've already searched through various chatbots, Ultima archives, shareware collections, and old CD-ROM indexes without finding it.

At this point I'm mostly hoping someone sees this and goes "holy shit, I remember that." 🙏🥹

I've been developing Nitor, an easy to use, cross platform 2D and 3D game engine for Pascal and optional C, inspired by the simplicity of Orbis Basic and Blitz3D. The main idea is simple: write your game once and use the same source code on Windows, Linux, and retro consoles, without rewriting everything for different hardware or learning a new SDK.

Nitor provides a complete game development environment with 2D drawing, sprites, animation, scrolling worlds, GUI controls, text input, pathfinding, audio, music, and video playback. Its 3D engine includes all simple to use Blitz3D commands, supporting meshes, skeletal animation, terrain, collisions, lighting, shadows, textures, cameras, and positional audio.

My next goal is direct console compilation, similar to my Orbis BASIC 32X compiler, which generates native Sega 32X ROMs with automatically converted and embedded assets.

The idea is that you develop, test and publish your game for Windows or Linux, select a console target, and compile the same code into a ready to distribute ROM, disc image, or CHD where supported. The compiler automatically converts and bakes textures, models, audio, and other assets into the final game.

I'm considering Nintendo 64, Sega Saturn, PS1, PS2, Dreamcast, GameCube, Wii, Wii U, and PS Vita.

Which console should Nitor support first?

TWLazUI LCL Components is a custom user interface (UI) component library package for Lazarus and Free Pascal. This project brings the modern, clean, and minimalist design aesthetics typical of TWLazUI CSS to desktop application development (VCL/LCL).

Powered by BGRABitmap, this library offers advanced graphic rendering such as true alpha transparency, ultra-smooth anti-aliasing, rounded corners, and drop shadow effects that cannot be achieved by native operating system components.

Link https://github.com/CodeInPas/TWLazUI

Feedback, bug reports, and contributions are very welcome. Let me know what you think!

Best regards,

Built on top of the BGRABitmap graphic engine, these components offer high-quality, anti-aliased rendering perfectly suited for simulation software, avionics dashboards, industrial control panels, and audio software interfaces (Virtual Instruments/Mixers).

🚀 Key Features

20+ Interactive Components: Ranging from simple switches to dynamic radar screens and oscilloscopes.

High-Quality Rendering: Utilizes BGRABitmap for smooth gradients, drop shadows, glowing elements, and glass reflections.

Highly Customizable: Tweak colors, value ranges, and component states directly through the Lazarus Object Inspector.

Self-Contained: Rendering is purely drawn via mathematical code and BGRABitmap (no reliance on external bitmap assets for UI logic).

Link

https://github.com/CodeInPas/SkeuoCom/tree/main

# Procedural Music Editor in Free Pascal – Sound DnB (9)

program dnb9;

{$mode objfpc}{$H+}

{$APPTYPE CONSOLE}

uses

SysUtils,

Classes, // only for file writing and reading

Math,

glfw3, gl33,

SterilTypes, SterilMath,

SterilWindow,

FrameLimiter,

RenderTypes, RenderQueue, RenderState, ShaderCore, SimpleRenderEngine,

MiniGUI,

AL,

FlacWriter,

SynthUnit;

I'm building a procedural music editor in Free Pascal (Object Pascal). It's a sequencer + synthesizer, currently mono 44.1 kHz for easier development. It produces loops and exports them. The codebase for the export side is a single unit, `FlacWriter.pas`. It's not object-oriented – just a record and functions that take `var` parameters. This fits the DOD style of the rest of the project.

---

## Sound List – Sound DnB 9

The program contains **30 generated sounds**, organized into **5 pages**. Each sound is an independent procedure inside `SynthUnit.pas`. There are no samples, no external files, everything is synthesized at runtime.

---

## 1. DRUMS (10 sounds)

**KICK** – Deep, punchy kick. Pitch envelope from 45 Hz to 180 Hz, with a click on the attack. 40 Hz decay, 6 Hz amplitude envelope.

**SNARE** – Classic snare. 190 Hz tone plus noise. 25 Hz tone decay, 18 Hz noise decay.

**HIHAT** – Closed hi-hat. HP-filtered noise, fast 60 Hz decay.

**OPEN** – Open hi-hat. Same as above, but with a longer release, 7 Hz decay.

**CLAP** – Clap. Four bursts (0 / 8 / 16 / 24 ms) plus a tail.

**RIM** – Rimshot. 800 Hz plus noise. 180 Hz decay, 400 Hz noise.

**TOM** – Tom. Pitch envelope from 80 Hz to 200 Hz. 15 Hz pitch, 8 Hz amplitude.

**RIDE** – Ride cymbal. Four sine waves (6.5 / 7.8 / 9.2 / 11 kHz) plus noise.

**CRASH** – Crash cymbal. Wide spectrum plus shimmer. 12 and 9 kHz shimmer, 1.2 Hz decay.

**SHAKER** – Shaker. HP-filtered noise, 80 Hz decay.

---

## 2. BASS (6 sounds)

**SUB** – Pure sine at 55 Hz. Sidechained. Suited to every deep style.

**REESE** – Two detuned saws (1.01×), SVF LP cutoff with LFO. DnB, dubstep.

**808** – Pitch envelope from 40 Hz to 80 Hz, soft saturation. Trap, hip-hop, DnB.

**FMBS** – FM bass at a 2:1 ratio, index 3.0. Bass house, techno.

**WOBBLE** – LFO-filtered saw at 8 Hz, cutoff between 150 Hz and 950 Hz. Dubstep, DnB.

**ACID** – 303-style saw plus resonant SVF, Q = 3.5, cutoff envelope. Techno, acid house.

---

## 3. SYNTHETIC SOUNDS (8 sounds)

**PAD** – Three detuned saws (±0.5%), 2500 Hz LP. Ambient, trance.

**STAB** – Four detuned saws, fast release. Dub techno, DnB.

**HOOVER** – Pitch-down saw from 1.0 to 0.5, with saturation. Rave, hardstyle.

**PLUCK** – Clean sine, 10 Hz decay. Minimal, dub techno.

**BELL** – FM bell, 1.4 ratio, index 3.0. Ambient, Nanosphere.

**SUPERSAW** – Seven detuned saws (±1.8%), 5000 Hz LP. Trance, EDM, modern DnB.

**EPIANO** – FM Rhodes, with an index that decays from 2.5 to 0. House, lo-fi, jazz.

**CHORD** – Three notes at once (root + third + fifth). House, dub techno.

---

## 4. FX (5 sounds)

**RISER** – HP-filtered noise with a rising envelope. Used before transitions.

**DOWN** – LP-filtered noise with a falling envelope. Used after drops.

**IMPACT** – 40 Hz sine plus a noise burst. Used before drops.

**RVCYM** – Reversed cymbal with a rising envelope. DnB, ambient.

**SUBDROP** – Sub sweeping from 120 Hz down to 25 Hz, plus noise. Used before drops.

---

## 5. AMBIENT (1 sound)

**DRONE** – Two detuned sines (1.0025×), 0.08 Hz LFO. Nanosphere, ambient, dub techno.

---

## Parameters

Every sound receives three parameters on playback.

The **velocity** ranges from 0 to 9, which maps to a volume between 0.0 and 1.0. It can be set independently on each step.

The **length** ranges from 1 to 16 steps. It controls the duration of the sound, again per step.

The **frequency** applies to the melodic sounds only, and is computed as `MELODY[i mod 8] × multiplier`.

The **MELODY** is an eight-note scale, ranging from A1 at 55 Hz up to D3 at 146.83 Hz. Every melodic sound multiplies this scale by a fixed factor:

**Pad** ×2, so 110 Hz when `MELODY[0]` = 55 Hz.

**Stab**, **Hoover**, **Pluck**, **Supersaw**, **EPiano** and **Chord** ×4, so 220 Hz.

**Bell** ×8, so 440 Hz.

**Sub**, **Reese**, **FMBass**, **Wobble** and **Acid** stay fixed at 55 Hz and do not follow the scale.

**Drone** ×1, so 55 Hz.

---

## Pages and Content

The **DRUMS** page holds 10 sounds: Kick, Snare, Hihat, Open, Clap, Rim, Tom, Ride, Crash, Shaker.

The **BASS** page holds 6 sounds: Sub, Reese, 808, FMBS, Wobble, Acid.

The **SYNTH** page holds 8 sounds: Pad, Stab, Hoover, Pluck, Bell, Supersaw, EPiano, Chord.

The **FX** page holds 5 sounds: Riser, Down, Impact, RevCymbal, SubDrop.

The **AMBIENT** page holds 1 sound: Drone.

The grid displays 8 rows at a time; the rest is reachable with the mouse wheel.

---

## Effects on the Sounds

The sounds go through the master FX chain dry. There, in order:

First, the **sidechain** acts, but only on the bass sounds (Sub, Reese, 808, FMBS, Wobble, Acid).

Then comes the **drive**, which is oversampled tanh plus a DC blocker.

Next, the **master EQ** with three bands: low shelf at 200 Hz, peak at 3 kHz, high shelf at 6 kHz.

After that, the **reverb**, which is Schroeder-based, with adjustable size, decay and damp.

Then the **compressor** with threshold, ratio, attack, release and makeup parameters.

Then the **limiter**, using the ceiling value.

Finally, the **out gain**, the **peak normalize** stage, and the **16-bit conversion**.