DualBrain/Samples

This repository is a collection of Visual Basic .NET sample projects demonstrating a wide range of .NET capabilities, including game loops, audio processing, and serial communication. It features experimental implementations of language features such as Roslyn source generators and BASIC-to-VB transpilers, alongside utilities for file system comparison and API integration. The codebase serves as a practical reference for retro-style graphics rendering, terminal user interfaces, and modern Windows Forms customization.

13 changes.

This period established the Samples repository with an initial release of diverse Visual Basic .NET projects, including game loops, audio processing, and interpreter implementations. The work expanded to cover modern .NET features such as high-DPI support, source generators, and custom WinForms controls, while migrating dependencies to .NET 8.

13 changes.

This period focused on expanding the repository with diverse sample applications, including WinForms games, browser controls, and Twitter integration, while introducing new source generators for VB.NET forms and implicit interfaces. Significant work also went into experimental compiler features, such as a QBasic dialect and BASIC-to-VB conversion prototypes, alongside updates to high-DPI handling and UAC prompt utilities.

13 changes.

This period focused on expanding the project's sample library with diverse game loop implementations across WinForms, FNA, SDL2, and Raylib, alongside low-level audio processing examples. It also involved migrating classic QBasic games to .NET and introducing experimental tools like a BASIC-to-VB transpiler and an offline wiki browser.

8 changes.

This period focused on expanding the project's capabilities with a new X11 graphics backend featuring hardware-accelerated rendering and a BASIC-style API. Significant work also went into serial communication tools, including terminal examples, data transfer utilities, and testing frameworks. Additionally, new example projects were added to demonstrate sorting algorithms, JSON API usage, and various other features.

The BasicComputerGames project now includes three new playable titles: Acey-Ducey (a card betting game), Amazing (a maze-generation game), and Cube (a 3D grid navigation game with mine avoidance). These are implemented as standalone Visual Basic console applications, preserving the legacy BASIC style (e.g., GOTO/line-number logic) while running on the modern .NET 8 runtime.

BasicComputerGames · high confidence

A new console application sample named CompareFolders has been added to demonstrate comparing file structures between two directories. The tool recursively scans a source and target folder, filtering out common metadata files (such as AlbumArt\_, folder.jpg, and thumbs.db), and identifies files present in one directory but not the other. This serves as a reference implementation for folder synchronization or auditing tasks.

CompareFolders · high confidence

A new FNA-XNA sample has been added to the GUI/FNA\_Gameloop directory, providing a complete Visual Basic game loop implementation. This sample demonstrates how to initialize the FNA graphics device, handle keyboard, mouse, and gamepad input, and render textures using the XNA-style Game class structure.

_GUI/FNA\Gameloop · high confidence

A new sample project has been added to the GUI/SDL2\_Gameloop location, demonstrating an FNA-XNA style game loop implemented in Visual Basic. The sample utilizes the SDL2-CS library to handle window creation, rendering, and input, providing a reference implementation for integrating SDL2 with this specific graphics API style.

_GUI/SDL2\Gameloop · high confidence

New sample projects have been added to demonstrate specific .NET capabilities. The FileSystemWatcherSample provides a console application that monitors a specified directory for changes to .txt files (creation, modification, deletion, and renaming) and logs these events. The SoundBeepPlay sample introduces a multi-file audio playback engine built on NAudio, featuring support for streaming and cached audio, mixing, and event-driven playback control, along with a console-based demo that generates and plays tones.

FileSystemWatcherSample, SoundBeepPlay · high confidence

A new console application named Json101 has been added. It iterates through a hardcoded list of GitHub repositories, fetches their latest releases via the GitHub API, and prints the release tag, creation date, and total asset download counts to the console.

Json101 · high confidence

The CompilerApiBook now includes a new QBasic dialect implementation (Dialect.Qb.vb) that defines keywords, functions, operators, and symbols for the language, alongside the IDialect interface it implements. This change also introduces a tokenization pipeline (Tokenizer, Token classes) and a sample program (Program.bas) demonstrating how QBasic source code is parsed, converted to Visual Basic, and compiled using the Roslyn compiler API.

CompilerApiBook · high confidence

A new .NET 8 sample application has been added that demonstrates a recursive quicksort implementation in VB.NET. The program sorts a list of integers using a generic QSort function and prints the result to the console.

QSortModern · high confidence

This change introduces a new SourceGenerators directory containing a Visual Studio solution (SourceGenerators.sln) and a README with setup instructions. The solution includes a 'SourceGeneratorSamples' project and a 'GeneratedDemo' project that demonstrates how to use the generators. The samples require Visual Studio 16.9.0 or higher and are intended for experimentation with Roslyn Source Generators, including a proof-of-concept RecordGenerator for VB.

SourceGenerators · high confidence

A new TestConsoleApp has been added to the SourceGenerators directory to provide a dedicated environment for testing and experimenting with code generators. The application includes sample code structures, such as a Form1 class with extensive UI control logic and data lookup initialization, allowing developers to verify the behavior of generators like RecordGenerator and ImplicitInterfaceGenerator in a controlled setting.

SourceGenerators/TestConsoleApp · high confidence

A new sample application has been added to the Twitter location, demonstrating how to send tweets using Single-user OAuth. The implementation includes a \TwitterApi\ class that handles OAuth 1.0 signature generation (HMAC-SHA1) and HTTP requests to the Twitter API, along with a \Program\ entry point that initializes the API with consumer and access tokens to post a tweet.

Twitter · high confidence

The ConsoleApp1 project now includes new Visual Basic samples demonstrating specific language and library behaviors. Byref.vb illustrates how ByRef parameters behave differently when called from within a Structure method versus a standalone Sub, highlighting mutation semantics. HttpClientDownloadWithProgress.vb provides a reusable class for downloading files with progress reporting via events. Inline.vb introduces a module of AggressiveInlining helper functions for incrementing and decrementing primitive types (Byte, Integer, Long, etc.) by reference, returning the new or old value. Program.vb integrates these samples, including a test of the HTTP download progress feature and calls to the inline increment helpers.

ConsoleApp1 · high confidence

A new sample application, VbScriptRepl, has been added to the ClearScript library. This .NET 6 console application provides a Read-Eval-Print Loop (REPL) interface for VBScript, allowing users to interactively execute scripts. It leverages Microsoft ClearScript's Windows scripting engine and includes support for loading a startup script, exposing host types and objects to the script environment, and handling basic command input and output.

ClearScript · high confidence

The Audio sample area now includes a new Program.vb utility that enumerates available audio devices using WMI, NAudio's WaveOut/WaveIn (noting API changes in v2.x), DirectSound, WASAPI, and ASIO backends. Additionally, a new Rtttl2Play sub-project provides a command-line tool that parses Nokia/RTTTL ringtone strings and converts them into Picaxe TUNE file syntax, supported by new Melody and Note data classes.

Audio · high confidence

This change introduces new example projects in the Serial directory to demonstrate serial communication capabilities. The PC-To-Centurion tool provides a console application for transferring data (specifically 'HawkDump' images) to a device via a serial port, handling sector-based transfers with CRC verification and retry logic. Additionally, the Term project includes a serial terminal example with three progressively advanced implementations: a basic terminal, a terminal with echo and background receiving, and an ANSI-capable terminal that parses and renders ANSI escape sequences for cursor control, screen clearing, and text attributes.

Serial · high confidence

The ClassLibrary1 library now includes new C\# record types (A, B, and C) alongside a static method demonstrating inline assignment and increment/decrement operators. This change introduces experimental syntax features for immutable data structures and expression-level side effects, primarily intended for internal exploration rather than production use.

ClassLibrary1 · medium confidence

A new project placeholder has been added to the GUI/Raylib\_Gameloop location, consisting of a basic Visual Basic console application entry point and a README file. The README provides links for further research into Raylib and its C\# bindings, indicating this is an exploratory setup rather than a functional game loop implementation.

_GUI/Raylib\Gameloop · high confidence

A new console application (SerialTesting/Program.vb) has been added to facilitate serial communication testing. It initializes a SerialPort connection with configurable baud rate, parity, and handshake settings, then enters a loop to read data from the port, calculate CRC checksums for received sectors, and send acknowledgment responses. The tool supports manual termination via the Escape key and includes logic to handle timeouts and connection errors.

SerialTesting · high confidence

The Sound directory now includes several new example programs demonstrating low-level audio capabilities. These include direct WinMM API wrappers for playing tones and wave files (2secTone, WaveOut, WaveOutBuffered, ThreadPlayer, ThreadPlayerRing), a continuous tone generator with device enumeration (ContTone), a GW-BASIC PLAY emulator supporting Tandy 1000 MML syntax (Play2Wav), a MOD file sample extractor (ModExtract), and an FFmpeg-based media information scanner (FFMpeg).

Sound · high confidence

The SourceGenerators/GeneratedDemo project now includes a console application that demonstrates several source generators, including AutoNotify, CSV, XML Settings, Mustache, and Record generators. The demo uses sample data files (Cars.csv, People.csv, MainSettings.xmlsettings) to showcase how these generators create strongly-typed classes and properties at compile time, allowing users to see generated code in action for features like automatic property notification, data model generation from CSV/XML, and template-based constant generation.

SourceGenerators/GeneratedDemo · high confidence

The InsaneSourceGeneration project now includes experimental files demonstrating a conversion from BASIC to Visual Basic. A new Program.BAS file contains a simple BASIC script, while Program\_Generated.vb shows the corresponding converted VB.NET code, including variable declaration and console output adjustments. A stub Program.vb file is also added as a placeholder.

InsaneSourceGeneration · high confidence

The Transpiler module now includes an experimental prototype that converts legacy BASIC code (specifically targeting QB64-style syntax) into modern Visual Basic. This change introduces three new source files: \Program.vb\ serves as the entry point, using the Roslyn compiler platform to parse and rewrite BASIC syntax trees; \RemLine.vb\ provides logic to strip line numbers from input code by tracking GOTO/GOSUB targets; and \VbRewriter.vb\ contains the core syntax rewriting logic, such as transforming BASIC PRINT statements into System.Console calls. This is a proof-of-concept implementation rather than a production-ready feature.

Transpiler · high confidence

Adds the main entry point for the terminal user interface, establishing a window with a menu bar (File, Edit, Assorted, ScrollView), a status bar with help and quit shortcuts, and a scrollable view area. The application includes demo views for text alignments and a pulsing progress indicator, along with custom views for a 10x10 box and a filler pattern, providing a baseline interactive experience for terminal-based navigation and display.

Tui · high confidence

Added a new GameLoop2 project that implements a basic Windows Forms game loop. The application features a main form (Form1) that renders falling characters ('Invaders') and allows users to type matching keys to 'hit' them, tracking hits, misses, and failures in the window title. The implementation uses a custom timer-based loop within the Paint event to update and redraw the game state, with high-DPI settings configured as DpiUnaware.

GameLoop2 · high confidence

This entry marks the initial commit of the Samples repository, establishing the foundational solution file (Samples.sln) and directory structure for a wide variety of Visual Basic .NET projects. The diff introduces over 80 project references spanning console applications, WinForms, and game loops using libraries such as SDL2, Silk, FNA, and Raylib. It also includes samples for source generation, serial communication, audio processing (WaveOut, Libsoundio), and conversions of classic QBasic and BASIC Computer Games titles. The commit adds a comprehensive README.md detailing these categories and updates .gitignore to exclude specific NES ROM files used in the One Lone Coder (OLC) pixel game engine experiments.

(repo-wide) · high confidence

This entry introduces the GameLoop1 sample, a new Windows Forms application demonstrating a game loop pattern using the QB.Video library for retro-style graphics rendering. The project has been upgraded to .NET 5 and includes configuration for high-DPI awareness, specifically setting the application to DpiUnaware mode in the application framework while providing the necessary infrastructure to handle high-DPI events if needed.

GameLoop1 · high confidence

A new source generator (FormExGenerator) is added for Visual Basic projects. By decorating a class with the \<FormEx\> attribute, the generator automatically produces a partial class that implements standard form behaviors (such as loading, closing, and state management) and exposes properties like IsLoading, IsNew, and IsDirty. It also generates constructors and handles common events, reducing boilerplate code for form initialization and data binding.

FormExGenerator · high confidence

A new sample application named PLAYground has been added to the project. It implements a parser and interpreter for the GW-BASIC/QB 'PLAY' macro language, allowing users to input macro strings via command-line arguments or interactive console input to generate audio output (using NAudio). The tool supports standard PLAY commands such as note definition, octave shifting, tempo control, and note durations, and can optionally save the generated audio to a WAV file.

PLAYground · high confidence

The UacPrompt application has been added, providing a Windows Forms interface that displays a message box on a secure desktop to bypass standard User Account Control (UAC) restrictions. The implementation uses unmanaged Windows API calls (such as CreateDesktop, SwitchDesktop, and MessageBoxTimeout) to create a temporary secure desktop, display a Yes/No dialog with a timeout, and then restore the original desktop environment. Users can trigger this secure prompt via the main form's button, which displays a confirmation message based on the user's selection or if the timeout expires.

UacPrompt · high confidence

The WinFormsApp1 sample now includes a suite of custom controls under the Community.Windows.FormsEx namespace, including PanelEx, ComboBoxEx, ToolStripComboBoxEx, and custom scroll bars (HScrollBarEx, VScrollBarEx, ScrollBar). These controls provide enhanced appearance options, such as customizable border colors and widths, and are designed to support both light and dark themes. The application also introduces a DarkMode utility class that leverages Windows API calls to enable immersive dark mode on Windows 10 and later, along with a DarkColorTable to customize the appearance of standard menu and toolbar elements. Additionally, the sample application now features a WebView2 control for displaying web content.

WinFormsApp1 · high confidence

The QBasic area now includes .NET implementations of the classic Microsoft QBasic examples: the Gorilla and Nibbles games, and the RemLine utility. These projects replace the original DOS-era code with modern Visual Basic .NET, leveraging the QB.Compatibility library to preserve the original logic and structure while running on the .NET runtime. The Gorilla and Nibbles games utilize Windows Forms for their UI, while RemLine operates in the console.

QBasic · high confidence

Added new WinForms sample applications for a Browser and a Webcam. The Browser sample integrates a WebView2 control to display web content, enforcing HTTPS-only navigation and applying a custom dark theme to the menu and status strips via a ProfessionalColorTable override and Windows DWM API calls. The Webcam sample provides a basic interface for accessing the device camera. Both samples include application-level event handlers to configure high-DPI awareness.

WinForms · high confidence

This change introduces several new example projects to the OLC/Other folder, including a terminal-based Cave Diver game, a Lua embedding demonstration using the NLua library, a Snake game, and a four-part series on building a sound synthesizer (covering waveforms, oscillators, envelopes, and sequencing). A README file has also been added to document these examples.

OLC/Other · high confidence

The WinFormBugs project now includes a new PanelEx control that wraps child controls (such as ListBox, RichTextBox, and TextBoxBase) with a customizable border and an integrated custom scrollbar. This control, part of the Community.Windows.FormsEx library, provides a dark-mode themed scrollbar (ScrollBarDarkMode) and handles high-DPI scaling via the ApplicationEvents and HighDpiMode configuration in the application framework.

WinFormBugs · high confidence

The SourceGeneratorSamples directory now includes a collection of sample source generators for Visual Basic, providing templates and proof-of-concept implementations for various code generation scenarios. These samples include AutoNotifyGenerator for automatic INotifyPropertyChanged implementation, CsvGenerator for compiling CSV data into strongly typed classes, HelloWorldGenerator as a basic entry point, ImplicitInterfaceGenerator for inferring interface implementations, MustacheGenerator for template-based code generation, RecordGenerator for creating immutable record-like types, and SettingsXmlGenerator for loading XML settings into typed classes.

SourceGenerators/SourceGeneratorSamples · high confidence

A new WinForms-based game loop sample has been added to the GUI/WinForms\_GameLoop directory. It features a main form that renders graphics using a PictureBox and a QbScreen helper class, which provides a BASIC-like API for drawing lines, circles, and pixels. The implementation uses buffered graphics to minimize flicker and includes a simple demo loop that draws random shapes while displaying the frame rate in a label. Users can switch between drawing modes using the spacebar and exit the application by pressing Escape.

_GUI/WinForms\GameLoop · high confidence

The application now includes a new X11-based graphics subsystem that provides a BASIC-like drawing API (QB module) for SCREEN, COLOR, CLS, PSET, and LINE operations, backed by a software FrameBuffer and BitmapFont for text rendering. The X11Backend supports both CPU-based rendering and hardware-accelerated XRender compositing, with the latter enabled by default and the former accessible via the --cpu command-line flag for performance comparison. The main program loop implements a game-loop pattern with FPS monitoring and event polling, allowing users to run graphical demos with real-time performance metrics.

GUI/X11 · high confidence

An offline, console-based wiki browser for QB64 has been introduced, featuring a custom markdown parser and lexer. This tool allows users to browse QB64 documentation locally without an internet connection, parsing markdown files into a structured syntax tree and displaying help content via a text-based interface. The implementation includes a dedicated lexer, syntax node/token classes, and a program module that indexes keywords, statements, and functions for quick lookup.

QB64 · high confidence

A new Tiny BASIC interpreter has been added to the project, implemented in Visual Basic within the TinyBASIC module. This change introduces the core runtime logic, including a two-pass parser/tokenizer and an execution engine that supports standard BASIC commands such as PRINT, INPUT, GOTO, IF/THEN, and REM. The interpreter features an interactive command-line interface that displays a 'Ready' prompt, handles line entry and storage, and provides error reporting for syntax issues.

TinyBASIC · high confidence

The ScanMkDn tool now includes a hardcoded mapping of legacy blog archive URLs to their new permanent locations, generating IIS URL Rewrite rules to handle these redirects. This change supports the migration of content from the old blog structure to the new site layout, ensuring that visitors accessing old archive links are automatically forwarded to the correct posts.

ScanMkDn · high confidence

The WinForms game loop application now explicitly sets its high-DPI mode to DpiUnaware via the auto-generated Application.Designer.vb file. This ensures the application handles scaling consistently across different display resolutions without automatic DPI awareness adjustments, which is a common configuration for game loops or custom rendering scenarios where the application manages its own scaling.

_GUI/WinForms\GameLoop/My Project · high confidence

The ImplicitInterfaceGenerator source generator has been updated to handle interface methods and properties that include parameters. Previously, the generator likely only supported parameterless members; it now inspects parameter signatures when matching interface members to class implementations, allowing implicit wiring for more complex interface contracts. This change is part of the generator's move to a separate, publishable project.

SourceGenerators/ImplicitInterfaceGenerator · high confidence

Visual Studio generated the initial project structure for the TestFormsApp, including the main Form1, application entry point, and resource files. As part of this setup, the application framework is configured to run in DpiUnaware high-DPI mode, meaning the app will not automatically scale its UI for high-resolution displays unless explicitly handled later.

TestFormsApp · high confidence

Visual Studio has added the initial scaffolding for a .NET 6 WinForms application, including the main form (Form1), application entry point, and resource files. A key behavioral detail is that the auto-generated Application.Designer.vb explicitly sets the HighDpiMode to DpiUnaware, which affects how the application scales on high-DPI displays compared to the newer PerMonitorV2 default.

_WinFormsApp\dotNet6 · high confidence

Added VB.NET test project for NuGet package validation; Added sorting algorithm performance test.

The majority of sample projects and libraries in this location have been updated to target .NET 8.0, with a few remaining on .NET 7.0 or .NET Framework 4.7.2. Several projects now enable Native AOT publishing (PublishAot) and invariant globalization. External dependencies have been refreshed, including NAudio (up to 2.1.0), Microsoft.CodeAnalysis (up to 4.1.0), NLua (1.6.2), FFMediaToolkit (4.5.1), and Terminal.Gui (1.7.2).

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 60 → 57 (-3.4)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 66 → 66 (-0.2)
• Architecture 99 → 99 (+0.0)
• Maturity 57 → 51 (-6.3)
• Readiness 50 → 50 (+0.0)
• Security 100 → 78 (-22.5)

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)

• BitmapFont.DrawDigit (cognitive 17) (GUI/X11/BitmapFont.vb)
• Duplicated block (13 lines × 2) (GUI/X11/BasicGraphics.vb)
• End-of-life runtime: .NET net7.0
• End-of-life runtime: .NET net9.0
• Medium: security finding (details withheld)
• OnErrorResumeSwallow (UacPrompt/Form1.vb)
• OnErrorResumeSwallow (UacPrompt/Form1.vb)
• OnErrorResumeSwallow (UacPrompt/Form1.vb)
• OnErrorResumeSwallow (UacPrompt/Form1.vb)
• TodoComment (GUI/X11/X11Backend.vb)
• TodoComment (GUI/X11/X11Backend.vb)
• TodoComment (GUI/X11/X11Backend.vb)
• X11Backend.PollEvents (cognitive 28) (GUI/X11/X11Backend.vb)

• Containers 1 added · 0 removed · contexts 0 added · 0 removed · edges 0 added · 0 removed

• cli:X11_GameLoop

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

DualBrain/Samples was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.