C++17 & C++ 20 error-handling and utility extensions.

Related tags

Miscellaneous STX

C++ 17 & C++ 20 error-handling and utility extensions.


STX is a collection of libraries and utilities designed to make working with C++ easier and less error-prone.



  • Efficient Result<T, E> (error-handling) and Option<T> (optional-value) implementation with monadic methods
  • Unignorable error-types
  • Fail-fast (Abandonment/ Fatal failure) via panic s
  • Reporting via Report ( SpanReport and FixedReport )
  • Runtime panic hooks
  • Panic backtraces
  • Signal backtraces ( SIGSEGV , SIGILL , and SIGFPE )
  • Backtrace library
  • Portable, suitable, and easily-adoptable for embedded systems, real-time systems, safety-critical systems, and operating systems
  • Easy debugging
  • Easy to use and hard to misuse API
  • Exception-free, RTTI-free, and memory allocation free ( no-std )
  • Space and time deterministic error-handling
  • Deterministic value lifetimes
  • Eliminates repitive code and abstractable error-handling logic code via monadic extensions
  • Fast success and error return paths
  • Modern and clean API
  • Well-documented
  • Extensively tested
  • Functions using only Result and Option for error and optional value handling are callable from C code as they are unions.

Basic Examples


#include <iostream>

#include "stx/option.h"

using stx::Option, stx::Some, stx::None;

auto safe_divide(double numerator, double denominator) -> Option<double> {
  if (denominator == 0.0) return None;
  return Some(numerator / denominator);

int main() {
  safe_divide(5.0, 2.0).match(
      [](auto value) { std::cout << "Result: " << value << std::endl; },
      []() { std::cout << "Cannot divide by zero" << std::endl; });


#include <array>
#include <cinttypes>
#include <iostream>

#include "stx/result.h"

using std::array, std::string_view;
using namespace std::literals;

using stx::Result, stx::Ok, stx::Err;

enum class Version { V1 = 1, V2 = 2 };

auto parse_version(array<uint8_t, 6> const& header) -> Result<Version, string_view> {
  switch (header.at(0)) {
    case 1:
      return Ok(Version::V1);
    case 2:
      return Ok(Version::V2);
      return Err("Unknown Version"sv);

int main() {
  parse_version({2, 3, 4, 5, 6, 7}).match([](auto version){
    std::cout << "Version: " << static_cast<int>(version) << std::endl;
  }, [](auto error){
    std::cout << error  << std::endl;


Propagating Errors with TRY_OK

TRY_OK assigns the successful value to its first parameter version if parse_version returned an Ok , else propagates the error value.

// As in the example above
auto parse_version(array<uint8_t, 6> const& header) -> Result<Version, string_view>;

auto parse_data(array<uint8_t, 6> const& header) -> Result<uint8_t, string_view> {
  TRY_OK(version, parse_version(header));
  return Ok(version + header[1] + header[2]);

int main() {
  auto parsed = parse_data({2, 3, 4, 5, 6, 7}).unwrap();

  std::cout << parsed << std::endl;

You can also add const/volatile attributes to TRY_OK 's assigned value, i.e:

auto parse_data(array<uint8_t, 6> const& header) -> Result<uint8_t, string_view> {
  TRY_OK(const version, parse_version(header));
  return Ok(version + header[1] + header[2]);


  • Result and Option will only work in constexpr context (compile-time error-handling) in C++ 20, to check if you can use it as constexpr check if the macros STX_RESULT_IS_CONSTEXPR and STX_OPTION_IS_CONSTEXPR are set to 1, for an example see constexpr_test .

  • To ensure you never forget to use the returned errors/results, raise the warning levels for your project ( -Wall -Wextra -Wpedantic on GNUC-based compilers, and /W4 on MSVC)

  • Some methods like map , unwrap, or_else, and most of Result and Option's monadic methods consume the stored value and thus the Result or Option has to be destroyed as its lifetime has ended. For example:

    Say we define a function named safe_divide as in the example above, with the following prototype:

auto safe_divide(float n, float d) -> Option<float>;

And we call:

float result = safe_divide(n, d).unwrap(); // compiles, because 'safe_divide' returns a temporary
Option option = safe_divide(n, d);
float result = option.unwrap();  // will not compile, because 'unwrap' consumes the value and is only usable with temporaries (as above) or r-value references (as below)

Alternatively, suppose the Option or Result is no longer needed, we can obtain an r-value reference:

Option option = safe_divide(n, d);
float result  = std::move(option).unwrap(); // will compile, the value is moved out of 'option' , 'option' should not be used any more

NOTE: Just as any moved-from object, Option and Result are not to be used after a std::move ! (as the objects will be left in an unspecified state).

  • Result and Option do not make any implicit copies of the contained object as they are designed as purely forwarding types, this is especially due to their primary purpose as return channels in which we do not want duplication nor implicit copies of the returned values.

To make explicit copies:

Option option = safe_divide(n, d);
float result = option.clone().unwrap(); // note that 'clone()' explicitly makes a copy of the 'Option'

We can also obtain an l-value reference to copy the value:

Option option = safe_divide(n, d);
float result = option.value(); // note that 'value()' returns an l-value reference and 'result' is copied from 'option''s value in the process
float result = safe_divide(n, d).value(); // this won't compile as 'value' always returns an l-value reference, use 'unwrap()' instead
  • All methods of Result and Option pass r-value/l-value references to their invocable parameters.


Release Mode ( -O3 )

Target Real Time CPU Time Iterations
Variant/SuccessPath 0.392 ns 0.392 ns 1000000000
Exception/SuccessPath 0.386 ns 0.386 ns 1000000000
Result/SuccessPath 0.381 ns 0.381 ns 1000000000
C-Style/SuccessPath 0.387 ns 0.386 ns 1000000000
Variant/FailurePath 0.408 ns 0.408 ns 1000000000
Exception/FailurePath 2129 ns 2129 ns 317810
Result/FailurePath 0.384 ns 0.384 ns 1000000000
C-Style/FailurePath 0.384 ns 0.383 ns 1000000000

Build Requirements

  • CMake
  • Make or Ninja Build
  • C++ 17 or C++ 20 Compiler
  • Git
  • Doxygen and Graphviz (for documentation)

Tested-on Compilers

Compiler x86-64 arm-linux aarch64-linux
Clang-10 YES NO NO

CMake Configuration Options

  • STX_BUILD_SHARED - Build STX as a shared library
  • STX_BUILD_TESTS - Build test suite
  • STX_BUILD_DOCS - Build documentation
  • STX_BUILD_BENCHMARKS - Build benchmarks
  • STX_SANITIZE_TESTS - Sanitize tests if supported. Builds address-sanitized, thread-sanitized, leak-sanitized, and undefined-sanitized tests
  • STX_CUSTOM_PANIC_HANDLER - Override the global panic handler and define a new one in another source file
  • STX_ENABLE_BACKTRACE - Enable the backtrace library
  • STX_ENABLE_PANIC_BACKTRACE - Enable panic backtraces. It depends on the backtrace library ( STX_ENABLE_BACKTRACE )
  • STX_VISIBLE_PANIC_HOOK - Make runtime panic hooks attachable when loaded as a dynamic library (i.e. device drivers)


MIT License

  • Provide a usable way to add the library into other projects

    Provide a usable way to add the library into other projects


    Since now in C++ we have normal dependency manager (Conan), would be fine, if you provide a package for your library and add it to the central conan repository.

    You can choose several options:

    • Add your package in conan-center repo
    • Add your package in bincrafters repo
    • Create your own repo and use this repo as a hosting for your library.

    Also don't forget to provide installation instructions in README.

    Thank you a lot.

    opened by zamazan4ik 8
  • build options `STX_BUILD_SHARED` and `STX_ENABLE_BACKTRACE` seem incompatible

    build options `STX_BUILD_SHARED` and `STX_ENABLE_BACKTRACE` seem incompatible

    Describe the bug I tried to build STX as shared library with backtraces enabled, yet the build fails during linking.

    [email protected]:/tmp/tmp.Y7OX2c2Ms5/STX/build2 > /tmp/tmp.Y7OX2c2Ms5/cmake-3.18.2-Linux-x86_64/bin/cmake .. -DSTX_BUILD_SHARED=ON -DSTX_ENABLE_BACKTRACE=ON -DCMAKE_CXX_STANDARD=17                                                                                                                                              12:33:09
    -- The CXX compiler identification is GNU 8.4.0
    -- Detecting CXX compiler ABI info
    -- Detecting CXX compiler ABI info - done
    -- Check for working CXX compiler: /usr/bin/c++ - skipped
    -- Detecting CXX compile features
    -- Detecting CXX compile features - done
    -- [STX] Build as a shared library: ON
    -- [STX] Build tests: OFF
    -- [STX] Enable debug mode assertions: OFF
    -- [STX] Build documentation: OFF
    -- [STX] Build benchmarks: OFF
    -- [STX] Build sanitized tests: OFF
    -- [STX] Override panic handler: OFF
    -- [STX] Make runtime panic hook visible: ON
    -- [STX] Enable backtrace: ON
    -- [STX] Enable panic backtrace: ON
    -- Performing Test LIBSTX_SUPPORTS_WPEDANTIC_FLAG - Success
    -- Performing Test LIBSTX_SUPPORTS_WALL_FLAG
    -- Performing Test LIBSTX_SUPPORTS_WALL_FLAG - Success
    -- Performing Test LIBSTX_SUPPORTS_WEXTRA_FLAG - Success
    -- Performing Test LIBSTX_HAS_STD_THREAD_MUTEX
    -- Performing Test LIBSTX_HAS_STD_THREAD_MUTEX - Success
    -- Looking for C++ include pthread.h
    -- Looking for C++ include pthread.h - found
    -- Performing Test CMAKE_HAVE_LIBC_PTHREAD
    -- Performing Test CMAKE_HAVE_LIBC_PTHREAD - Failed
    -- Looking for pthread_create in pthreads
    -- Looking for pthread_create in pthreads - not found
    -- Looking for pthread_create in pthread
    -- Looking for pthread_create in pthread - found
    -- Found Threads: TRUE  
    -- Configuring done
    -- Generating done
    -- Build files have been written to: /tmp/tmp.Y7OX2c2Ms5/STX/build2
    [email protected]:/tmp/tmp.Y7OX2c2Ms5/STX/build2 > cmake --build .                                                                                                                                                                                                                                                                 12:33:19
    [52/168] Linking CXX shared library libstx.so
    FAILED: libstx.so 
    : && /usr/bin/c++ -fPIC    -shared -Wl,-soname,libstx.so -o libstx.so CMakeFiles/stx.dir/src/backtrace.cc.o CMakeFiles/stx.dir/src/panic/hook.cc.o CMakeFiles/stx.dir/src/panic.cc.o  third_party/abseil/absl/debugging/libabsl_stacktrace.a  third_party/abseil/absl/debugging/libabsl_symbolize.a  third_party/abseil/absl/debugging/libabsl_debugging_internal.a  third_party/abseil/absl/debugging/libabsl_demangle_internal.a  third_party/abseil/absl/base/libabsl_malloc_internal.a  third_party/abseil/absl/base/libabsl_base.a  third_party/abseil/absl/base/libabsl_spinlock_wait.a  -lrt  third_party/abseil/absl/base/libabsl_dynamic_annotations.a  -lpthread  third_party/abseil/absl/base/libabsl_raw_logging_internal.a  third_party/abseil/absl/base/libabsl_log_severity.a && :
    /usr/bin/ld: third_party/abseil/absl/debugging/libabsl_stacktrace.a(stacktrace.cc.o): relocation R_X86_64_PC32 against symbol `_ZNKSt6atomicIPFiPPvPiiiPKvS2_EE4loadESt12memory_order' can not be used when making a shared object; recompile with -fPIC
    /usr/bin/ld: final link failed: Bad value
    collect2: error: ld returned 1 exit status
    [69/168] Building CXX object third_party/abseil/absl/flags/CMakeFiles/absl_flags_usage_internal.dir/internal/usage.cc.o
    ninja: build stopped: subcommand failed.
    1 [email protected]:/tmp/tmp.Y7OX2c2Ms5/STX/build2 >                                                                                                                                                                                                                                                                               

    Given the error message I'm not sure if this is actually an STX issue / how abseil is included/configured through cmake / an issue in abseil.

    Expected behavior I expected these options can be toggled independently of each other

    Desktop (please complete the following information):

    • OS: ubuntu 18.04 LTS
    • Browser chromium
    • Version 85.0.4183.83-0ubuntu0.18.04.2

    Additional context

    • cmake version 3.18.2
    • g++ (Ubuntu 8.4.0-1ubuntu1~18.04) 8.4.0
    opened by pseyfert 5
  • Wrapped inside a promise

    Wrapped inside a promise

    Add a possibility to create std::promise/std::future with stx::Result inside.

    auto p = std::promise<stx::Result<A, B>>();

    Thank you

    opened by Invander29 5
  • propagate triviality, extend constexpr

    propagate triviality, extend constexpr

    this is a bit of a big PR since a bunch of changes were coupled. my intention was to just extend constexpr support and that required more machinery until i ended up with something that mirrors the standard's optional<T> (as well as most high quality optional implementations)

    Option<T> is now trivially copy/move constructible/assignable, and/or trivially the destructible when the same is true for T. which makes those operations constexpr in c++17. when all of those are trivial, the optional is trivially copyable, which allows a good amount of compiler optimizations. (e.g. with trivial copyability, calls malloc or uses vectorized instructions. without trivial copyability, copies the data one by one)

    in c++20 they can always be constexpr, by using std::construct_at instead of placement new

    additionally, when the type T is trivial and default constructible, we store Option<T> as a T+bool, instead of a tagged union. this allows all operations to be constexpr.

    the same optimizations can be applied to Result<T, E>, but i thought i'd get some feedback before i go ahead with that

    opened by sarah-ek 4
  • Compatibility with asio

    Compatibility with asio

    First of all, I want to congratulate you on the project, as it seems to me quite interesting. It will help a lot for those who try to standardize projects made in c++ and rust. But it would be interesting to use it in a project involving asio (boost/standalone).

    opened by kassane 4
  • Prepare a release

    Prepare a release


    Can you please make a GitHub release for your library? It makes much easier to lock version of the library in other projects. Also it makes easier to prepare packages for your library in Conan

    Thank you a lot.

    opened by zamazan4ik 4
  • consider merging overloads that take ownership of a value

    consider merging overloads that take ownership of a value

    rather than having two overloads, one that takes by const& and another that takes by &&, we could merge them into a single one that takes the object by value, then moves it into its slot.

    with two reference constructors, passing an lvalue calls the copy constructor, and passing an rvalue calls the move constructor with one value constructor, passing an lvalue calls the copy constructor, then the move constructor, and passing an rvalue calls the move constructor twice.

    so the cost is having to move the object one more time. but moves are cheap and compilers can elide them in most cases where it matters ( example , we get roughly equivalent generated assembly with a vector, for instance)

    on the other hand, this can help avoid code duplication, and lessen the load on the compiler that comes from having to resolve the correct overload in each instantiation

    opened by sarah-ek 3
  • clang-format


    adding a .clang-format config file to the project root would make it a bit easier to contribute, since we wouldn't have to worry about autoformatters modifying code we didn't author

    opened by sarah-ek 3
  • Span allows undesirable conversions

    Span allows undesirable conversions

    Describe the bug Span<Base> can be constructed from Span<Derived> (or some container of Derived), but iterating over (or indexing) into that Span<Base> will cause undefined behavior if sizeof(Base) != sizeof(Derived).

    Expected behavior The constructors should only allow cv qualifier adjustments, like Span<int> -> Span<const int>, not everything that is permitted by static_cast<pointer>(source.data()).

    opened by melak47 3
  • unresolved external symbol stx::v1::begin_panic

    unresolved external symbol stx::v1::begin_panic

    Describe the bug When building the library with STX_BUILD_SHARED on MSVC (VS2019 16.7.3), trying to use it leads to a linker error:

    error LNK2019: unresolved external symbol "void __cdecl stx::v1::begin_panic(
        class std::basic_string_view<char,struct std::char_traits<char> > const &,
        class stx::v1::ReportPayload const &,
        struct stx::v1::SourceLocation const &)" 
    ([email protected]@stx@@[email protected][email protected]@std@@@std@@[email protected]@[email protected]@@Z)
    referenced in function "void __cdecl stx::v1::panic<struct io::Error>(
        class std::basic_string_view<char,struct std::char_traits<char> > const &,
        struct io::Error const &,
        struct stx::v1::SourceLocation const &)" 
    ([email protected]@io@@@[email protected]@@[email protected]?$c[email protected]@std@@@std@@[email protected]@@[email protected]@@Z)

    The begin_panic function is called from the panic function template, which gets instantiated in user-code, so I think begin_panic would have to be conditionally marked STX_EXPORT as well.

    Expected behavior If using the library as a DLL on windows is a supported scenario, it should work.


    • OS: Windows 10
    • Version 19041
    opened by melak47 3
  • Option<T&> specialization

    Option specialization

    Is your feature request related to a problem? Please describe. I absolutely love using the STX library. However, I always run into a problem when I want to return an optional reference to something, and do not have the provided facilities. For example, I have a map class map<int, ExpensiveType>. I want to have my lookup function return a reference to the value if the key exists, and None if the key does not exist. Being able to return stx::Option<ExpensiveType&> would allow me to maintain my functional programming approach to my code instead of returning a raw pointer or throw exception, etc...

    Describe the solution you'd like Create a template specialization for stx::Option<T&> that under that hood only holds a pointer to the T. I would strongly argue that stx::Option<T&> should not be re-assignable into order to mimic reference semantics and this avoids the debate on weather the assignment operator should assign through to the T. Also, the interface of Option<T&> would be limited when compared to the non-reference version. E.g. replace and unwrap_or_default would not be available for the Option<T&> interface.

    Describe alternatives you've considered The only other option to achieve the following is stx::Option<stx::Ref<T>> however, this is not optimal as you can represent the Option reference as just a pointer instead of a reference wrapper and a bool.

    Additional context I have a branch of STX where I implement the Option<T&> specialization and would gladly create a PR in the case this feature is considered a good idea to add. Note: I would also consider extending this to include Result<T&, E>, Result<T, E&>, and Result<T&, E&> specialization. However, as of right now, I believe Option<T&> has many more use cases and is quite practical/trivial to implement.

    opened by NathanSWard 2
  • TODO: Proposed API & Packaging Improvements (+ Planned Breaking Changes)

    TODO: Proposed API & Packaging Improvements (+ Planned Breaking Changes)

    • [x] rename and separate config.h into stx_cfg_utils as users might think they need to modify the config header file to use STX
    • [x] Make Option and Result‘s value and error methods conform to the C++ object model and use references.
    • [x] Document exception guarantees
    • [x] Some, Ok, and Err are value forwarders, hence, they shouldn’t have any other method or operations whatsoever, even copy.
    • [x] Make the methods external to Result and Option and support const references, l-value references, and r-value references.
    • [x] Separate Option and Result and use helper functions to resolve the tight dependencies. (stx_option, stx_result). This would also enable us to use SFINAE to dispatch methods where necessary without too much code.
    • [x] Separate panic features into separate stx_panic package, there should be no dependency on non-STX packages by default.
    • [x] Evaluate if panic could benefit from branch guiding i.e. [[unlikely]]
    • [x] Report should also be under the panic package
    • [x] Separate panic implementations (stx_panic_halt, stx_panic_abort, etc.)
    • [x] add stx_panic_pretty_stacktraced package
    • [ ] Make panic always use an injectable function pointer (hooks) since it’s always in the cold path and panics should only happen once before permanent termination.
    • [x] Let the user customize panic behavior at runtime only and not via cmake config which is already confusing.
    • [x] Make Option and Result actually use std::invoke
    • [x] reduce and streamline methods in Option and Result to make it easier to maintain and extend (i.e. redundant methods like most Option::*).
    • [x] [TOP PRIORITY] add specialization for Result<void, Error>
    • [x] Replace mutexes with a custom hybrid spin lock implementation as embedded systems don’t support it
    • [x] Consider using fmt or fmt-style interface for panics. It should be allowed to use dynamic memory
    • [x] Remove static methods in Span and make them helper functions instead.
    • [x] Replace SpanReport and FixedReport with better and safe alternatives, consider:
    • [ ] add default reporters for enum types. By just casting to the enum’s underlying type. I’ve found it quite tedious implementing reporters for each enum type for each API I’m using. Sometimes I’m satisfied with integers.
    • [x] let Option and Result be constexpr for constexprable trivial types
    • [ ] Explore other light-weight and portable alternatives to absl’s backtrace which is quite heavy and slows down our build at the moment
    • [x] Remove all noexcept statements and defaulted constructors and operators (See: https://github.com/lamarrr/STX/issues/31)
    • [x] Move option and result comparison operations outside of the structures and to a separate header
    • [ ] Verify and add tests for panic hooks if possible
    • [x] Simplify and rewrite CMake File
    • [ ] Change documentation solution
    • [ ] Draft tutorials
    • [x] Clean up and publish the internally developed async and task library (could help @Invander29 https://github.com/lamarrr/STX/issues/9)
    • [x] Publish the remaining internally used utilities (enums, struct, limits, etc).
    • [ ] Logo and brand change
    • [x] Remove coroutine macros
    • [x] SFINAE macros + header
    • [x] Option and Result SFINAE support? I’m not convinced this is important
    • [ ] Allow projects to inject namespaces or symbol overrides (I.e. where there are multiple or same STX versions packaged differently).
    • [x] stx_mem stx_res stx_limits stx_enum
    • [ ] Add clang format file + CI check (https://github.com/lamarrr/STX/issues/27)
    • [ ] Add more ARM and embedded systems CI tests
    • [x] remove libatomic auto linking find_library(LibAtomic atomic)
    • [x] remove TRY_OK and TRY_SOME and replace with STX_TRY?
    • [x] rename CFG to STX_CFG?
    • [x] a number of const& are unnecessary since the types are cheap to copy
    • [ ] add CI examples building
    • [ ] add CI clang format checks
    • [ ] consider making Result and Option's destructive methods allow l-value references
    opened by lamarrr 4
Investigate kernel error call stacks

retsnoop retsnoop is BPF-based tool that is meant to help debugging kernel issues. It allows to capture call stacks of kernel functions that return er

Andrii Nakryiko 75 Jan 4, 2023
repo to house various LLVM based SIHFT passes for RISCV 32/64 soft error resilience

compas-ft-riscv COMPAS: Compiler-assisted Software-implemented Hardware Fault Tolerance implemented in LLVM passes for the RISC-V backend Repo to hous

EDA@TUM 2 Jan 10, 2022
First-up chord-send and tap-and-hold chord repeat extensions to QMK.

Quantum Mechanical Keyboard Firmware This is a keyboard firmware based on the tmk_keyboard firmware with some useful features for Atmel AVR and ARM co

Joshua Grams 8 Dec 14, 2022
An extension manager for browsing and installing GNOME Shell Extensions.

Extension Manager A native tool for browsing, installing, and managing GNOME Shell Extensions. Written with GTK 4 and libadwaita. Features The tool su

Matt Jakeman 579 Jan 1, 2023
C Extensions i made for DragonRuby!

drext C Extensions i made for DragonRuby NOTE: DragonRuby Pro required for C Extensions. List Name Description Platforms drbat Battery information lib

Rabia Alhaffar 5 Dec 5, 2022
Some extensions for windows explorer, tested on windows 10+

WindowsExplorerExtension Extensions for windows explorer, tested on windows 10 & windows 11. New Folder Extension What's This A Gnome nautilus inspire

anpho 4 Jan 13, 2022
Examples of C extensions in Ruby gems

Ruby C Extensions, Explained Background How To Use This Repository Strategies Strategy 0, "isolated" Strategy 1, "system" Strategy 2a, "packaged_sourc

Mike Dalessio 62 Dec 30, 2022
Useful UE4 Visual Studio extensions.

UE4 Smarter Macro Indenting This extension was designed to fix the unnecessary and annoying "smart" indenting that Visual Studio likes to do around va

Chris Pawlukowsky 250 Dec 16, 2022
Wayfire plugin for handling touchpad gestures globally in a layer-shell surface

wf-globalgestures Global touchpad gestures plugin for Wayfire: implements a special protocol (also in this repo) that lets clients request that a part

null 3 Oct 3, 2022
John Walker 24 Dec 15, 2022
Utility to install kexts, Frameworks and PrivateFrameworks in the System of macOS. For macOS Monterey 12 and Big Sur 11

Command-Line-SnapShot-Mounter Credit: chris1111 Apple This utility uses the macOS terminal Command Line SnapShot Mounter is an utility that allows you

chris1111 23 Jan 8, 2023
Basic definitions and utility functions for GNSS raw measurement processing

gnss_comm Authors/Maintainers: CAO Shaozu (shaozu.cao AT gmail.com) The gnss_comm package contains basic definitions and utility functions for GNSS ra

HKUST Aerial Robotics Group 70 Dec 21, 2022
sc-ble-bridge is a utility that for every connected Steam Controller creates a virtual one acting as a bridge between SC and Steam

sc-ble-bridge The main goal of this utility is to provide workaround for steam-for-linux issue which makes Valve's Steam Controller unusable in BLE mo

null 5 Apr 19, 2022
A Native Binary Emulator Library and Utility

binmulator A Native Binary Emulator Library and Utility Most emulators for malware detection are written in Python and fail when certain emulated API

c3rb3ru5 3 Jun 27, 2022
A utility to automate the installation, maintenance, and debugging of Asterisk/DAHDI, while integrating additional patches to provide the richest telephony experience

PhreakScript A utility to automate the installation, maintenance, and debugging of Asterisk/DAHDI, while integrating additional patches to provide the

null 14 Dec 22, 2022
ZSV/lib: a fast CSV parsing library and standalone utility

Please note: this code is still alpha / pre-production. Everything here should be considered preliminary. If you like ZSVlib, please give it a star! Z

null 96 Dec 30, 2022
xsnip - a minimal and convenient screenshot utility for X11

xsnip - a minimal and convenient screenshot utility for X11 Most screenshot utilities compatible with X are clumsy, use bloated toolkits, and often do

null 25 Sep 8, 2022
flashrom is a utility for detecting, reading, writing, verifying and erasing flash chips

flashrom is a utility for detecting, reading, writing, verifying and erasing flash chips

null 614 Dec 26, 2022
Simple and Fast Network Utility Library

SFNUL Simple and Fast Network Utility library © binary1248 SFNUL is provided under the Mozilla Public License Version 2.0 (see LICENSE for details)

null 49 Feb 17, 2022