Remember those old console racing games we grew up playing on the small CRT boxes? AV-Racer is a 2D top down retro style arcade racing game inspired in style by that nostalgia and in gameplay by the spirit of retro arcaders.

Features

• CRT style graphics:

Convex screen, curved edges, scan-lines, RGB shift, static, and on/off TV effects are emulated to chase that feeling of childhood nostalgia in games.

• Fast paced racing:

Push will come to shove in this one. Paint the roads with tire tracks and cover your opponents with smoke as you battle for first in a fast paced circuit racing format. Learn the track and memorize the corners to nail your approach. Utilize going offtrack and cutting corners to your advantage and slide ahead the competition.

Race up to 10 drivers, against a challenging AI system. No rubber banding, no handicaps, no artificial boosts, learn the track, take corners right and you will get ahead.

• 14 different race locations:

Race at 14 different locations with 24 different track setups. Hand crafted tracks with corners inspired by famous tracks around the world. Look out for Easter Eggs!

• 5 different car classes and championships:

Climb your way from the Junior league to the World Series in 5 car classes. Collect trophies in 5 different championships; Junior, Senior, Professional, Endurance, and World Championship. Progress in the career to unlock car classes and tracks to play in single player and split screen

• Split-Screen local Multiplayer mode:

Share the crazy action with a friend and compete locally in a Two-Player mode against each other or with AI, using the tracks an cars unlocked in Career.

Devlog: https://wassimulator.com/blog/programming/av-racer-overview.html

wcap is simple and efficient screen recording utility for Windows 10.

It uses Windows.Graphics.Capture API available since Windows 10 version 1903, May 2019 Update (19H1) to capture contents of window or whole monitor. Captured texture is submitted to Media Foundation to encode video to mp4 file with hardware accelerated H264 codec. Using capture from compositor and hardware accelerated encoder allows it to consume very little CPU and memory.

Get latest binary here: wcap.exe (WARNING: Windows Defender or other AV software might report false positive detection)
Or get source code on github: https://github.com/mmozeiko/wcap

Features

• press Ctrl + PrintScreen to start recording current monitor (where mouse cursor currently is positioned)
• press Ctrl + Win + PrintScreen to start recording currently active window
• press Ctrl + Shift + PrintScreen to select & record fixed position area on current monitor
• press any of previous combinations to stop recording right or double-click on tray icon to change settings
• video encoded using H264/AVC or H265/HEVC
• audio encoded using AAC or FLAC
• for window capture can capture full window area (including title bar/borders) or just the client area
• optionally exclude mouse cursor from capture
• can limit recording length in seconds or file size in MB's
• can limit max width, height or framerate - captured frames will be automatically downscaled

Metadesk is an ergonomic parser library for a simple—yet versatile—plaintext language. The language lets you create simple structures and define their meaning with your own code. The library provides the parser, and helpers for introspection and code generation.

Website: dion.systems/metadesk

GitHub Repository: github.com/dion-systems/metadesk

API Docs: dion.systems/metadesk_reference

RemedyBG is a 64-bit Windows debugger written from scratch with the goal of replacing the behemoth Visual Studio debugger.

Formerly, the idea was to integrate RemedyBG into the Vim text editor. However, doing so has slowed down development due to Vim's underpowered scripting language Vimscript (I'm no Tim Pope) along with how integrating external C-code was done (through Vim 8's jobs feature and through stdin/stdout/stderr -- ouch). I finally decided to ditch Vim (for this project, not as a text editor!) and render text windows in the debugger, instead. This also gives me the flexibility of rendering some interesting things like control flow arrows and so forth.

I, for one, fully support the handmade philosophy: RemedyBG doesn't use any third-party libraries (*). This includes Window's own Debug Help Library (DbgHelp), Debugger Engine (DbgEng), or even a library for reading symbol files (PDBs). I played around with these libraries to judge their effectiveness. Yes, using them can get you 80% of the functionality you need very quickly but after that you are forever 20% away from sweetness. And besides, Visual Studio is using these libraries and the whole point was to get away from this beast! All the code for RemedyBG is written from scratch which allows for a great deal of flexibility with respect to the functionality that can be implemented. There are a lot of interesting features coming down the pipe after realizing the wealth of information that the compiler emits.

(*) One caveat with respect to third-party libraries is that RemedyBG uses Intel's XED for diassembly. However, if you take a look at their dependencies they list the following: memcmp, memset, memcpy, strcmp, strncat, and strlen. No memory allocation, etc. Beautiful. I can get behind a library like this. Also, for the user interface, I am using Dear ImGui which has been a joy to use.

raylib is a simple and easy-to-use library to enjoy videogames programming.

raylib project was originally developed for education, while I was working as a teacher, I needed a simple library to teach videogames development to young people with artistic profile, most of them had never written a single line of code. I decided to start with C because I consider very important to understand the roots of programming and how things really work in the background. I was looking for a simple C library for videogames programming but none in the market fit my needs and my teaching methodology, so, I decided to create my own: raylib.

raylib has been used with several thousand students to date with amazing results. They have learnt the basis of videogames programming with raylib, including the videogames working mechanisms: game life cycle, frame-time management, screens management, resources loading/unloading, variables updating, frame drawing, collisions detection and resolution, etc.

Thanks to the students continuous feedback, raylib has grown during this time with hundreds of improvements and additions; right now in raylib webpage there are more than 120 code examples to start with the library and more than 20 sample games to learn videogames programming.

raylib is free and open-source.

DOWNLOAD LATEST raylib RELEASE!

---

NOTE for ADVENTURERS: raylib is a programming library to enjoy videogames programming; no fancy interface, no visual helpers, no debug button... just coding in the most pure spartan-programmers way. Are you ready to learn? Jump to the code examples!

Darke Files is a version control and file synchronization system. Its goal is to scale seamlessly between

• a full-featured version control system where you can work with branches and inspect and act on a rich version history (similar to version control systems programmers use today, like Git) and
• a file synchronization tool that is a simple app running in the background regularly uploading your changed files to the cloud so that you can forget that it exists in the day-to-day operation (similar to the cloud synchronization services everyone else uses, like Dropbox or Google Cloud).

Darke Files can scale between those two extremes in a single repository. This enables teams with a wide range of requirements for such a system to work on the same project.

Features

Works with every file

• regardless whether you're using small text files or huge binary files, Darke Files handles them all
• no matter what OS you're using, Darke Files won't try to change your line endings out from under you

Simple vs sophisticated even in a CLI

• one-command way to synchronize your changes with the server with daf sync if you don't care about the details
• supports all the details with individual commits, refs (branches and tags) on both client and server, full-featured history, and merges when you need them

Leaves your files alone

• Darke Files knows its limits and won't change your files
• you know better how to solve merge conflicts so Darke Files steps aside to allow the pro to do their thing

Powerful, customizable, machine-readable access to a repository

• daf info and its powerful template language lets you easily read out everything from a repository

Can I start using this right now?

Yes, but only if you can fulfill all of the following requirements:

• you keep backups of your repositories (this is still alpha software)
• you are ok with scrapping history if you decide to stop using Darke (there is no way to export a repository to a different VCS yet)
• you and everyone else who will be working on the same Darke repository trust each other and are on the same trusted network (there is no user login and authentication/authorization yet)

Also, Darke is missing all of the following:

• editor integrations, file explorer integrations, GUI tooling
• development metrics, tasks, issues, tickets, merge/pull requests, reviews, bots, wikis, CI/CT/CD/CD

Changelog

0.2.1 - 2022-06-19

• Features
  • Added status function to daf info
  • Added --keep-changes flag to daf switch
  • Enable upload progress bars
  • Added admin endpoint to server at /admin including metrics at /admin/metrics
  • Automatically renew data protocol certificates
• Changes
  • Specify minimum supported TLS version of data protocol as TLS 1.2
  • Guard better against path traversal attacks
• Fixes
  • Clone command overwriting an already existing local repo
  • A few visual bugs of the progress bar
  • Server not showing anything when a directory is empty
  • Various fixes related to repo metadata on the server

0.2.0 - 2022-05-21

• Features
  • Added daf download-file and daf upload-file commands
  • Added daf info command
  • Added ignoring files with daf ignore and daf ignore -p
  • Added option to specify file in darke config
• Changes
  • Made TLS for data protocol mandatory using self-signed certificates
  • Major improvements to diffing and merging
  • Major improvements to daf sync
• Fixes
  • Fixed edge cases everywhere

0.1.0 - 2021-10-03

• Initial release

Motivation Programming is difficult.

Our squishy human brains struggle to simulate what the computer will do when it runs our code. As a result we make lots of errors, many of them small, requiring us to divert our attention from the main problem we're working on to fix minor implementation details. This both takes up time and makes us lose focus on the high-level design.

The computer is going to run our code anyway, so why not do so immediately to check what it does?

Tool Overview WhiteBox runs the code as it is written, capturing details about the execution. It can then give you live feedback about the run, showing you how variables change over time and other details.

This is intended to improve the developer experience by helping you to understand your code faster, and consequently:

• catch and fix bugs earlier, before they cause major issues
• iterate more often over your design, giving more opportunity for refinement

Tool Internals WhiteBox is written in C and C++ with few external libraries:

• Clang/LLVM is used for lazily JIT compiling code
• Dear ImGui is used for creating the UI
• A few single-header libraries are used for various utilities (STB, Mattias Gustavsson, Randy Gaul's cute_headers)

Just about everything else is written from scratch, including:

• the hash table implementation
• DWARF debug info parsing
• plugins for code editors
• ...

Project Details WhiteBox has most of the initial set of features implemented and is nearly ready for alpha release.

Supported languages: C (and a small subset of C++) Supported platforms: Windows Supported code editors: 4Coder, Notepad++, Vim, (plus workarounds that should work for most other editors)

Support for more of each of these is planned or currently in-development.

Project Links Discussion and initial (free) access to the alpha at https://discord.gg/xHgepxM Development (and Discord voice chat) streamed live at https://www.twitch.tv/azmreece Preorder at https://azmr.itch.io/whitebox More information and a mailing list at http://whitebox.systems

As an esteemed Knight of the Rotund Table, your trusty lance is the only thing you can, well, trust. Use it to impale your enemies, knock arrows out of the sky, and fling yourself to victory. Fight your friends, or fight alongside them, in online versus or co-op multiplayer!

Sir Happenlance started out as a challenge we set for ourselves to finish and ship a commercial game in (about) one month. It's written mostly from scratch in C++ using OpenGL for graphics, but we do use Box2D for physics, SoLoud for audio, and SDL2 as a platform layer. We have been publishing devlogs documenting our progress and explaining the design and technical decisions we make along the way.

The Odin programming language is designed with the intent of creating an alternative to C with the following goals:

• simplicity
• high performance
• built for modern systems
• joy of programming

Website: https://odin-lang.org/

Documentation:

• Tutorial
• Frequently Asked Questions

User Libraries:

• Odin Libs

package main

import "core:fmt"

main :: proc() {
	program := "+ + * 😃 - /";
	accumulator := 0;

	for token in program {
		switch token {
		case '+': accumulator += 1;
		case '-': accumulator -= 1;
		case '*': accumulator *= 2;
		case '/': accumulator /= 2;
		case '😃': accumulator *= accumulator;
		case: // Ignore everything else
		}
	}

	fmt.printf("The program \"%s\" calculates the value %d\n",
	           program, accumulator);
}

import "core:fmt"

main :: proc() { program := "+ + * 😃 - /"; accumulator := 0;

for token in program {
	switch token {
	case '+': accumulator += 1;
	case '-': accumulator -= 1;
	case '*': accumulator *= 2;
	case '/': accumulator /= 2;
	case '😃': accumulator *= accumulator;
	case: // Ignore everything else
	}
}

fmt.printf("The program \"%s\" calculates the value %d\n",
           program, accumulator);

} [/code]

Demonstrations:

• First Talk & Demo
  • Talk
  • Demo
  • Q&A
• Composition & Refactorability
• Introspection, Modules, and Record Layout
• push_allocator & Minimal Dependency Building
• when, for & procedure overloading
• Context Types, Unexported Entities, Labelled Branches
• Bit Fields, i128 & u128, Syntax Changes
• Default and Named Arguments; Explicit Parametric Polymorphism
• Loadsachanges
• Packages, Bit Sets, cstring
  • Q&A