Krzosa Karol :: Linkedin | Github

Hi, I'm a programmer from Kraków, Poland. Feel free to shoot me an email: krzosa@pm.me, I'm usually happy to talk about stuff, even if I don't know you!

Demo :: Editing 1GB+ files in my text editor

250 million columns, 2.5 milion lines and 0 problems.

Demo :: Transcript browser

Browsing over 500 hours of lectures at lightning speed. Warning: sudden sound!

Demo :: Transcript browser improvements

Warning: sudden sound!

Demo :: Data visualization tool

Visualizing program data, the data points are sent from a running program (through shared memory) to the plotting app.

Programming tricks :: Sturdy config files

I recently came up with a nice trick - my application at startup requires a configuration file in order to run properly. There is a clear error scenario here - the file might not be there.

• To sidetrack this problem my program has global variables for all the variables in the config file, all with proper defaults and so on. Even if the user has done something horrible - the program can just ignore the problem.
• Next, my program stores the default config in a string so when the config file is not there the program creates it for the user.
• Once the config file has changed, the program tries to supply updated values into the global variables.

From the user perspective this is very nice because you only need one .exe file. The program will just magically create config files for you in some appdata folder. Of course, all of this is a major hassle for the programmer, but here, a little bit of metaprogramming can help greatly. You declare the variables in the metaprogram - and then puff - it generates loading routines, global variables and the data for you. It suprisingly works really well in practice and using global variables instead of some wacky hash table lookup function feels great.

Demo :: Multi-cursor text editor

Demo :: Programming language | Online playground

Small, statically compiled language, packaged as a stb-style library with permissive license (MIT), no dependencies. The user has almost full control over compilation. Here is a small code snippet:

import "raylib";

main :: proc(): int {
    InitWindow(800, 600, "Thing");
    SetTargetFPS(60);

    for !WindowShouldClose() {
        BeginDrawing();
        ClearBackground(RAYWHITE);
        DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
        EndDrawing();
    }
    CloseWindow();
    return 0;
}

And the simple api version for compiling this piece of code:

#define LIB_COMPILER_IMPLEMENTATION
#include "lib_compiler.h"

LC_Lang *lang = LC_LangAlloc();
LC_LangBegin(lang);
LC_RegisterPackageDir("../examples/");
LC_RegisterPackageDir("../pkgs");

LC_Intern name = LC_ILit("create_raylib_window");
LC_ParseAndResolve(name);
if (lang->errors) {
    LC_LangEnd(lang);
    return false;
}

LC_String code = LC_GenerateUnityBuild();
WriteToFile(code.data, code.len);

LC_LangEnd(lang);

Demo :: Optimized software rasterizer

I got inspired by Handmade Hero and decided to do a fun CPU rasterization project. Code is public. It uses AVX2 instructions and multi threading and the result is that you can walk at 30FPS/1080P through the Sponza palace. A little of that 90s game development vibe.

Demo :: Path finding visualizer

I wanted to write a little something with my programming language before I abandon it. It's a simple tool, it binds with raylib for graphics.

Demo :: Rendering 2 million circles

Here in the video I'm presenting a result of optimizing my OpenGL renderer. It can render 2 million circles, 36 triangles per circle, couple times per second. If you tried plotting 2 million points in python/matplotlib you would have died of age before the plot got rendered.

Demo :: Programming language overview

When I was looking for a job I decided to make a showcase video of the programming language I was working on. It goes over bunch of examples, programs and features. At this point the language is abandoned but it was a pretty cool project.

Demo :: Generics, programming language demo

Stepping through generics (templates) implemented in my programming language.