This is my personal site decicated to my open source work and other experiments. It can be seen as a small reference of all projects that I currently develop, contribute to, or maintain. I don't intend to publish here events from my personal or professional life or to promote projects that I worked on but are not open-source.
- blog::__asmbits - My blog, mostly dedicated to AsmJit, Blend2D, and C++ in general. In addition, this is a public place where I complain a lot :)
- github::asmjit - AsmJit organization on GitHub is home for AsmJit and related projects.
- github::blend2d - Blend2D organization on GitHub is home for Blend2D and related projects.
- github::cxxstuff - CXXStuff organization on GitHub contains lightweight solutions to some C++ problems I faced. Currently contains only compiler detection and a lightweight unit testing framework.
- github::jsstuff - Home for some JS libraries I wrote - node.js and browser related.
- github::kobalicek - My personal github repository where I park projects that are either small or don't belong to anywhere else.
- blend2d.com - Blend2D project homepage.
C++ is my favorite programming language that I use for all the low-level stuff that I do. The reason I like C++ most is because of zero-overhead abstractions. Although I also know C very well I don't start new projects in pure C anymore, I see C mostly as a language for creating ABI stable APIs. I'm currently interested mostly in high-performance stuff, JIT code generation, and CPU accelerated rendering of 2D graphics (in general anything that works with pixels and is taking advantage of SIMD).
- asmdb - Instructions database and utilities for X86 (X86/X64) and ARM (THUMB/A32/A64) architectures released into the public domain. Although not written in C++ (it's JSON data and JS tooling around it) I use it to generate highly compressed database of all instructions accessible through AsmJit API.
- asmjit - A complete yet lightweight JIT and AOT assembler and compiler. It can generate native code for x86 and x64 architectures and supports the whole x86/x64 instruction set - from legacy MMX to newest AVX512. It has a type-safe API that allows C++ compiler to do semantic checks at compile-time even before the assembled code is generated and executed.
- asmtk - Assembler toolkit based on AsmJit. A sister project that provides more functionality usually not required by JIT compilers. It provides assembler parser compatible with Intel syntax. AsmTK focuses more on non-JIT use cases and its future goal is to provide a foundation for creating libraries and executables.
- b2d [home] - Blend2D is a next generation 2D vector graphics engine written in C++. It features a built-in JIT compiler that generates high performance 2D pipelines at runtime, which are much faster than static pipelines used in today's 2D engines. Dynamic pipeline construction is the main difference between Blend2D and other 2D engines, and guarantees the highest possible throughtput by taking advantage of CPU features detected at runtime. Blend2D provides also a deferred and asynchronous rendering, which makes it seamless to integrate with event-based environments such as node.js and next generation UI toolkits that don't block while rendering their components.
- b2d-node [home] - A JS binding for Blend2D library built on top of njs (see below).
- broken - A minimalist unit testing framework for C++ which never allocates memory on the heap and doesn't use C++ exceptions. I designed this framework to be used in a continuous integration environment which uses valgrind for memory leak (and access) checks. The tool is used by asmjit and b2d at the moment.
- cult - a tool that runs series of tests to estimate how many cycles an X86 processor (either in 32-bit or 64-bit mode) takes to execute each supported instruction. The tool output is designed to be processed by additional tools.
- mathpresso - A C++ library designed to parse mathematical expressions and compile them into machine code. It's much faster than traditional AST or byte-code based evaluators, because there is basically no overhead in the expression's execution. The JIT compiler is based on asmjit and works on X86 and X64 architectures.
- mpsl - A shader language specification and implementation in C++ build on top of asmjit. The library was designed for b2d as an extension that brings a possibility to use 2D shaders in the engine, but made independent so it can be used by other projects. The idea is based on mathpresso, but the language was extended to support integer and floating point types, control flow, and functions. The project is much more complex than MathPresso.
- njs - Neutral JS (NJS) interface for C++ targeting multiple JS engines (only V8 atm) and environments (node.js vs V8-only). NJS was developed together with b2d-node as a result of many breaking changes in V8 engine that initially required many hours of refactoring. V8 is known for its breaking changes that did not only affect Chromium/Blink, but also many other projects, including node.js.
- simdtests - Repository that contains SIMD implementation of functions used in 2D libraries:
- DePNG - Optimized PNG reverse filter implementation that takes advantage of SIMD. The most tricky part was optimizing the Paeth reverse filter, which is faster than the original libpng implementation even if it's kept in pure C. Additionally, the optimized implementation is about 5 times faster than a C implementation and makes the whole decoding process of PNG images faster about 20%.
- DeJPEG - Optimized JPEG dezigzag, and YCBCR to RGB conversion.
- RGB/HSV - Highly optimized RGB/HSV conversion that takes advantage of SIMD instruction and runs about twice as fast as a baseline C implementation. The code is very tricky and uses floating point arithmetic together with bit manipulation. It can process more than one pixel in parallel and is easy to extend for supporting wider instruction sets like AVX and AVX-512.
- PixOps - Pixel manipulation optimizations. Contains an experimental cross-fade blitter that takes advantage of
pmaddubsw instruction. Not much faster than a pure SSE2 implementation thought.
Node.js is my favorite server-side environment that I use when implementing scalable web services. My node.js work is often related to application's architectures, APIs, data, and security. Recently I also started experimenting with web browsers and started a UI toolkit project and a 2D game engine, but these are just fun & relax projects.
- xpart - an extensible framework for building modular applications and parts with dependency management. It can be used to develop applications composing of multiple modules (parts) with a possibility to specify which modules to run. The framework itself defines a minimal interface that can be used to define modules, their dependencies, and a way how to start and stop them. It contains an interface for logging, module management, and application's lifetime management. The concept behind xpart is very different to the traditional 'web server is the app' approach used commonly in node apps.
- xql [fiddle] - SQL builder and utilities library for node.js (runs in browser as well). This library uses an expression tree to build SQL queries programmatically and it's one of the fastest libraries for building such queries for node.js, see xql-bench.
- xui [here]- Experimental UI toolkit that only creates a small layer between UI and DOM.
- asmgrid - instruction explorer based on asmdb.
- webciv - a civ-like game implemented completely in JS. It's a work-in-progress project that demonstrates how to render a professional looking game-map that is composited from textures and blendmaps. The renderer uses a pure <canvas> to render everything, including terrain and coast transitions.