Handmade Hero is an ongoing project by Casey Muratori to create a complete, professional-quality game accompanied by videos that explain every single line of its source code. The series began on November 17th, 2014, and is estimated to run for at least 600 episodes. Programming sessions are limited to one hour per weekday so it remains manageable for people who practice coding along with the series at home.
For more information, see the official website at https://handmadehero.org
Climb huge mountains, impale hundreds of enemies, and solve tricky physics puzzles... all using only a spear. Pole-vault yourself to victory in this epic joust-'em-up adventure — or face your friends in online co-op and PvP multiplayer!
When the king's army invaded Sir Happenlance's quaint countryside village he didn't think much of it - that is, until they broke into his home on shaky grounds and started a scuffle that ended in the tragic death of his wife. Now, Sir Happenlance has embarked on a quest to exact personal revenge on the king himself - and all who stand in his way. As an esteemed Knight of the Rotund Table, your trusty lance is now the only thing you can, well, trust.
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 and DXGI1.3 for graphics, but we do use Box2D for physics, ENet and Steamworks for networking, SoLoud for audio, and SDL2 as a platform layer. We also published some devlogs documenting our progress and explaining the design and technical decisions we make along the way!
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
Ctrl + PrintScreen
to start recording current monitor (where mouse cursor currently is positioned)Ctrl + Win + PrintScreen
to start recording currently active windowCtrl + Shift + PrintScreen
to select & record fixed position area on current monitorThe old-school virtual analog synthesizer: reimagined and perfected, optimized for creativity. Integrate follows in the footsteps of the virtual analog classics we still love today, bringing together a straightforward user interface with an intricate and colorful sound engine.
The plugin is available in both 32-bit and 64-bit formats for Windows. If support for new platforms is added, you will receive access to these for no additional cost.
Key features:
Supported hosts:
Watch the demo video: https://www.youtube.com/watch?v=akzaQSzrqO4.
Visit the website for full information: https://nakst.gitlab.io/integrate/.
An operating system I've been writing since ~June 2017. Although it's a long shot (and very optimistic), I ultimately intend it to replace Linux and Windows as a desktop operating system.
Brainroll is a sokoban inspired puzzle game where the main mechanic is that you slide on ice, making you take several steps instead of a single step each turn. This game is my first game and was created with the goal to ship a fully finished commercial game in the handmade spirit. It took be about 2 years of working on average 2 hours per day after my day job to finish it.
The codebase is heavily inspired by Handmade Hero where I used a similar subset of C++ to develop it. It uses Win32 as its platform API. OpenGL for graphics, Steam SDK for integrating with Steam features.
It was built in my own engine that I call "Maraton" which includes many of the features taught when following Handmade Hero such as Hot-Reloading of code, Sound mixing, debug systems, grahics abstraction, font baking. I also use an UI implementation inspired by Ryan Fleurys posts.
Brainroll Postmortem Part 1: History, Planning & Design
Brainroll Postmortem Part 2: Art & Assets
Brainroll Postmortem Part 3: Engine
Brainroll Postmortem Part 4: Movement, Ropes & Undo
You have to slide on ice where only will only stop if you collide with something else.
There are brain blocks that will stick to you and follow your every move. Use them to help Brainroll reach the goal.
Some brains are chained to magical pillars, they have hindered movement that you have to use to your advantage.
Doors can be opened by placing a brain block on a pressure plate.
Try to complete the levels with as few moves as possible in order to get all three trophies (bronze, silver & gold).
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 140 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!
Orca is a launcher and sandbox for applications based on WebAssembly. It allows downloading applications from a webpage and running them in a sandbox, as well as saving them in a local library for offline use.
The main Orca UI shows the apps in your local library. You can click an app icon to see its banner and a description of what the app does. Double-clicking launches the app in a new tab.
You can also run an app from the web by accessing a special orca link (provided by the developer of the app) in your web browser.
Applications started from the web are normally run in a transient way, meaning their data gets cleaned up once the app closes. Optionally, you can instruct Orca to cache the application into your local app library, allowing for easier future access and offline use.
As a developper, you can build an Orca application by packaging a WebAssembly module along with some resources into an 'app bundle' following this specific directory structure:
bundle dir/ ├─ run/ │ └─ main.wasm ├─ ressources/ │ ├─ icon.png │ ├─ banner.png │ └─ blurb.txt └─ localfs/
The icon is displayed in the library view of the Orca launcher, and the banner and blurb text get displayed when the app is selected.
You can then zip the app bundle, upload it on your web server, and point users to it with a custom url starting with orca://
.
When a user clicks an orca link, the browser automatically opens the Orca launcher, passing it the url. Orca downloads and uncompresses the bundle in a temporary folder, and runs it in a new tab. If the users requests to cache the app, the bundle is marked as persistent and moved to the local apps library.
As of the jam, not much! Currently applications can receive input such as mouse clicks and key events and are provided a GLES context into which they can draw their content.
Each application instance is run in a tab backed by a separate 'host' process, communicating with the main process through pipes. A host process creates a graphics surface that they expose to the main process, and setup a GLES context on that surface. They then load and run the app's WebAssembly module. The main process passes input events to host processes and displays their graphics surface when their tab is selected.
This jam entry was made as an idea-proofing step towards re-thinking the web from an application platform perspective.
The web does provide (or at least promises) huge benefits to both developers and users:
On the other hands, the real world experience with web apps is rather poor. They often have janky UIs, are slower than they should, don't work well unless you're using a specific browser or even a specific version of that browser.
As for the developer, they have to deal with byzantine frameworks and APIs, browser-specific quirks, and a particularly inadequate document model that's built into the core of the web technology.
The web was originally designed as a global hyperlinked knowledge base composed of documents. It then grew more dynamic features from there, adding more flexible layouting, animations, push protocols, scripting features, etc., and at one point we realized we can code entire applications in it.
The promises I mentionned above were also obvious, all the more so as Operating Systems failed to provide them. So it's no wonder web technologies have been broadly adopted to build and distribute applications. We're even to the point we're seeing hacks added on top of them to make web apps look like native desktop ones (ie electron).
But all of this comes at the price of layers and layers of accidental complexity, fragility and slowness. We're building applications on top of a tech stack grounded on a document oriented platform that was never meant to do what we're making it do. It only succeeded because the OSes failed.
What if instead we flipped things upside down and had Operating Systems that could seamlessly download applications using a cross-platform format, and run them in a truly sandboxed way?
What if they gave users the choice to run one-shot apps, or to cache some apps for offline use (and maybe optimize them for better perfs on the users' machine)?
What if they had a simple, understandable capability model that let users choose which operations each app is allowed to perform on their machine, which file they can access, which servers they can connect to, which input feed they can capture?
What if this system could provide standardized ways of embedding views of an application into another, interlinking contents, and sharing data across applications?
I personally think this would massively simplify web technology and infrastructure, enabling developers to write better, more performant and stable apps, and give user more freedom and agency over their relation with computing.
Note that on top of such a system, the legitimately great idea of an world-wide decentralized knowledge base and expression platform consisting of dynamic mixed media documents could still exists! It would consist of specific document formats displayed by different 'viewer apps' that would plug into the system as any other app.
I would even argue this part of the web would be better, because it would be much simpler to write custom viewer apps. Each viewer wouldn't have to carry all the weight and baggage of modern browsers, and could use the system embedding and cross-linking capabilities to leverage other simple apps. For instance, we can envision using our casual document reader with a document containing tabular data, and being able to leverage the features of a spreadsheet editor app on demand, to sort columns or display graphs out of them.
Of course I wasn't going to reinvent the OS, let alone the web, from scratch in a jam week :) Orca was written as an way to test some ideas of how it could look like in terms of app distribution and sandboxing. It was also a way to explore some of the problems that need to be solved, such as process isolation, inter-process communication and delegated drawing. Finally it's trying to hint at how we could 'put a foot in the door' early on, before coming up with entire browser or OS replacements.
The next step would be to add a capability system that allows user to give an app access to systems features (e.g. reading/writing files, making network connections, capturing camera/microphone feeds, etc.)
Exposing a solid core library and a standard UI API to developers would also be greatly beneficial in easing the creation of new Orca apps. In particular, I think that a UI API that also creates a structured description of itself as a by-product would yield a great deal of value, and serve as a base for hyperlinking/embedding/accessibility features, automation, etc.
Many community members have projects of their own. Want to join them? Create your own.
The following projects were submissions to our most recent jam. Learn more »