Abseil Common Libraries (C++)

Abseil - C++ Common Libraries

The repository contains the Abseil C++ library code. Abseil is an open-source collection of C++ code (compliant to C++11) designed to augment the C++ standard library.

Table of Contents

About Abseil

Abseil is an open-source collection of C++ library code designed to augment the C++ standard library. The Abseil library code is collected from Google's own C++ code base, has been extensively tested and used in production, and is the same code we depend on in our daily coding lives.

In some cases, Abseil provides pieces missing from the C++ standard; in others, Abseil provides alternatives to the standard for special needs we've found through usage in the Google code base. We denote those cases clearly within the library code we provide you.

Abseil is not meant to be a competitor to the standard library; we've just found that many of these utilities serve a purpose within our code base, and we now want to provide those resources to the C++ community as a whole.

Quickstart

If you want to just get started, make sure you at least run through the Abseil Quickstart. The Quickstart contains information about setting up your development environment, downloading the Abseil code, running tests, and getting a simple binary working.

Building Abseil

Bazel and CMake are the official build systems for Abseil.

See the quickstart for more information on building Abseil using the Bazel build system.

If you require CMake support, please check the CMake build instructions and CMake Quickstart.

Support

Abseil is officially supported on many platforms. See the Abseil platform support guide for details on supported operating systems, compilers, CPUs, etc.

Codemap

Abseil contains the following C++ library components:

  • base Abseil Fundamentals
    The base library contains initialization code and other code which all other Abseil code depends on. Code within base may not depend on any other code (other than the C++ standard library).
  • algorithm
    The algorithm library contains additions to the C++ library and container-based versions of such algorithms.
  • cleanup
    The cleanup library contains the control-flow-construct-like type absl::Cleanup which is used for executing a callback on scope exit.
  • container
    The container library contains additional STL-style containers, including Abseil's unordered "Swiss table" containers.
  • debugging
    The debugging library contains code useful for enabling leak checks, and stacktrace and symbolization utilities.
  • hash
    The hash library contains the hashing framework and default hash functor implementations for hashable types in Abseil.
  • memory
    The memory library contains C++11-compatible versions of std::make_unique() and related memory management facilities.
  • meta
    The meta library contains C++11-compatible versions of type checks available within C++14 and C++17 versions of the C++ library.
  • numeric
    The numeric library contains C++11-compatible 128-bit integers.
  • status
    The status contains abstractions for error handling, specifically absl::Status and absl::StatusOr.
  • strings
    The strings library contains a variety of strings routines and utilities, including a C++11-compatible version of the C++17 std::string_view type.
  • synchronization
    The synchronization library contains concurrency primitives (Abseil's absl::Mutex class, an alternative to std::mutex) and a variety of synchronization abstractions.
  • time
    The time library contains abstractions for computing with absolute points in time, durations of time, and formatting and parsing time within time zones.
  • types
    The types library contains non-container utility types, like a C++11-compatible version of the C++17 std::optional type.
  • utility
    The utility library contains utility and helper code.

Releases

Abseil recommends users "live-at-head" (update to the latest commit from the master branch as often as possible). However, we realize this philosophy doesn't work for every project, so we also provide Long Term Support Releases to which we backport fixes for severe bugs. See our release management document for more details.

License

The Abseil C++ library is licensed under the terms of the Apache license. See LICENSE for more information.

Links

For more information about Abseil:

Comments
  • Add CMake support

    Add CMake support

    Initial partial CMake support for abseil, created after the discussion of this afternoon.

    Do not merge yet, this is still incomplete.

    I created the pull request for tracking and avoid duplicated effort.

    Adev

  • to be or not to be: CMake install()

    to be or not to be: CMake install()

    Issue following the discussions on #8 : should we support install() in the cmake build:

    Pro:

    • required by people who do not use cmake in their project.
    • make the usage of package manager possible

    Cons:

    • make easy for to rely on ABI and have problems
  • Add a version number to the library + git tag

    Add a version number to the library + git tag

    Hello,

    I can't see any version number / scheme in the library. Does it exist? It would be nice to have such version numbers reflected via git tags (and probably the cmake file) in order to:

    • clone the repository on a specific tag in order to ensure repeatable builds & environment setup
    • know if a new version has been released and compare what's new regarding the version we are currently using

    That would probably imply to maintain a changelog file as well. It's a bit of more work but it's very useful for consumers like me.

    Aurelien

  • Don't #include <windows.h>

    Don't #include

    Currently it appears to be impossible to compile Abseil using VS 2017 without errors.

    Adding something like this resolve this problem with windows.h includes.

    # ifndef WIN32_LEAN_AND_MEAN
    #   define WIN32_LEAN_AND_MEAN
    # endif
    # ifndef VC_EXTRALEAN
    #   define VC_EXTRALEAN
    # endif
    # ifndef NOMINMAX
    #   define NOMINMAX
    # endif
    #include <windows.h>
    
  • Implement the Parallel Hashmap in Abseil

    Implement the Parallel Hashmap in Abseil

    see https://greg7mdp.github.io/parallel-hashmap/ for writeup.

    The new absl::parallel_flat_hash_map and absl::parallel_flat_hash_set have the same tests as the base maps and all tests pass on Windows (vs2017) and linux (g++ 5.4 and clang 3.8)

  • Cmake links all abseil components and results in a link time error

    Cmake links all abseil components and results in a link time error

    No matter what I try, cmake builds the whole abseil and then links everything into my shared library. I could reproduce this with a minimal cmake example:

    cmake_minimum_required(VERSION 2.8.12)
    project(my_project)
    set(CMAKE_CXX_FLAGS "-std=c++11 -fvisibility=hidden ${CMAKE_CXX_FLAGS}")
    add_subdirectory(abseil-cpp)
    add_library(my_lib SHARED main.cpp)
    include_directories(SYSTEM abseil-cpp)
    target_link_libraries(my_lib absl::hash absl::container)
    

    main.cpp contains only the following:

    #include <absl/container/flat_hash_map.h>
    int foo(void) {
    	absl::flat_hash_map<int,int> m;
    	return 0;
    }
    

    For an actual project where I'm trying to use abseil, I get a linker error in debug mode that says the following:

    /usr/sbin/ld: ../absail/absl/container/libabsl_container.a(raw_hash_set.cc.o): relocation R_X86_64_TPOFF32 against hidden symbol `_ZZN4absl18container_internal10RandomSeedEvE7counter' can not be used when making a shared object
    

    The project in question is here. Top level CmakeLists.txt Shared object defining CMakeLists.txt Abseil, at commit a06c4a1, is a submodule of my project. The build instructions are:

    • Clone bstaletic/ycmd and checkout aseil branch
    • git submodule update --init --recursive
    • mkdir build && cd build
    • cmake ../cpp -DCMAKE_BUILD_TYPE=Debug

    Other build time dependencies are python headers. For python3 -DUSE_PYTHON2=OFF is needed.

  • [Benchmark] flat_hash_map considerably slower than std::unordered_map

    [Benchmark] flat_hash_map considerably slower than std::unordered_map

    This is not a bug report, more of an interesting data point. In the past week I've been trying out absl::flat_hash_map and google::dense_hash_map (and sets) and comparing performance to STL counterparts.

    The following gist contains benchmarks for STL (Master), abseil and dense_hash_map: https://gist.github.com/bstaletic/7d3e31db7fc8d40a12787fab09ff092f

    The project whose benchmark results you're looking at is https://github.com/Valloric/ycmd The benchmarks test two separate algorithms, FilterAndSortCandidates and IdentifierCompleter.

    FilterAndSortCandidates benchmark

    This is benchmarking the function of the same name. This one actually has the best timings with abseil.

    IdentifierCompleter benchmark

    This is benchmarking this piece of code. Surprisingly, abseil is the slowest of the three.

    If there's interest to investigate my benchmark results further, I will gladly provide any information needed.

  • Support using Abseil via CMake find_package

    Support using Abseil via CMake find_package

    Hello,

    I have a bit of trouble using a local Abseil installation, as I dont want to depend on external packages with some fixes URL nor some fixed filesystem paths. Cmake already HAS the necessary infrastructure to allow building dependend modules.

    For using Abseil in your Project, just this would be necessary:

    # cctz pulls in some gtest and benchmark suites otherwise
    set (BUILD_TESTING OFF)
    find_package(Abseil REQUIRED
    )
    

    And, given the worst-case that abseil and cctz are in no directory that can be found automatically, configuration would add the respective paths: cmake -DAbseil_DIR=<local path> -DCctz_DIR=<local path> ...

    Basic support would be added by this patch (note that cctz would need to be fixed in a similar fashion):

    diff --git a/AbseilConfig.cmake b/AbseilConfig.cmake
    new file mode 100644
    index 0000000..4476b98
    --- /dev/null
    +++ b/AbseilConfig.cmake
    @@ -0,0 +1,2 @@
    +# Macros
    +include(${CMAKE_CURRENT_LIST_DIR}/CMake/AbseilMacros.cmake)
    diff --git a/CMake/AbseilMacros.cmake b/CMake/AbseilMacros.cmake
    new file mode 100644
    index 0000000..94c6886
    --- /dev/null
    +++ b/CMake/AbseilMacros.cmake
    @@ -0,0 +1,8 @@
    +# TODO: this should be another find_package(Cctz)
    +add_subdirectory(${Cctz_DIR} _libcctz
    +	EXCLUDE_FROM_ALL
    +)
    +
    +add_subdirectory("${CMAKE_CURRENT_LIST_DIR}/.." _libabseil
    +	EXCLUDE_FROM_ALL
    +)
    
  • Fix Randen and PCG on Big Endian platforms

    Fix Randen and PCG on Big Endian platforms

    Randen expects seed and state buffers to be in LE ordering even on BE machines, and PCG is not, but they both use a shared seed implementation which is currently favouring Randen.

    This patch fixes randen_slow to behave the same as RandenHwAes and reverse the byte order when necessary and changes seed generator to be in native byte order.

  • Use the implicitly defaulted constructor

    Use the implicitly defaulted constructor

    Defining an empty default constructor is worse than using the compiler generated constructor.

    Note that the compiler generated constructor requires that constexpr as well as exception specifiers are correctly considered. See Chapter 15.1 [class.ctor] paragraph 7

  • StrReadUntil(string_view&, string_view sep)

    StrReadUntil(string_view&, string_view sep)

    Request for a function like string_view StrReadUntil(string_view&, string_view sep)

    Returns the part until (not including) the separator and removes that part (including separator) from the input (in-place). Returns the entire input and clears it if separator isn't found.

    Examples: StrReadUntil(is, "\n"); // reads next line StrReadUntil(is, ";"); reads next value from 1;2;3

    It's a bit like getline() for string_views.

  • absl/debugging/CMakeLists.txt: link with libexecinfo if needed

    absl/debugging/CMakeLists.txt: link with libexecinfo if needed

    backtrace and execinfo.h can be provided by libexecinfo on uclibc and musl resulting in the following build failure with any user of abseil-cpp (such as collectd):

    /home/buildroot/autobuild/instance-0/output-1/host/lib/gcc/sparc-buildroot-linux-uclibc/10.3.0/../../../../sparc-buildroot-linux-uclibc/bin/ld: /home/buildroot/autobuild/instance-0/output-1/host/bin/../sparc-buildroot-linux-uclibc/sysroot/usr/lib/libabsl_stacktrace.so: undefined reference to `backtrace'
    

    [...]

        libgrpc++ . . . . . . no (libgrpc++ not found)
    

    [...]

    configure: error: "Some plugins are missing dependencies - see the summary above for details"
    

    Fixes:

    • http://autobuild.buildroot.org/results/6a0484412f020e763ce3ad5bda48f09c78645bff

    Signed-off-by: Fabrice Fontaine [email protected]

  • Help!!!  Undefined reference to absl::ByChar::Find(std::basic_string_view<char, std::char_traits >, unsigned long) const'

    Help!!! Undefined reference to absl::ByChar::Find(std::basic_string_view, unsigned long) const'

    [ 56%] Linking CXX executable cartographer_print_configuration CMakeFiles/cartographer_print_configuration.dir/cartographer/common/print_configuration_main.cc.o: In function cartographer::common::PrintSubdictionaryById(cartographer::common::LuaParameterDictionary*, std::__cxx11::basic_string<char, std::char_traits, std::allocator > const&)': print_configuration_main.cc:(.text+0x244): undefined reference to absl::ByChar::Find(std::basic_string_view<char, std::char_traits >, unsigned long) const' print_configuration_main.cc:(.text+0x65c): undefined reference to absl::ByChar::Find(std::basic_string_view<char, std::char_traits >, unsigned long) const' CMakeFiles/cartographer_print_configuration.dir/cartographer/common/print_configuration_main.cc.o: In function absl::strings_internal::Splitter<absl::ByChar, absl::SkipEmpty, std::basic_string_view<char, std::char_traits > >::ConvertToContainer<std::vector<std::basic_string_view<char, std::char_traits >, std::allocator<std::basic_string_view<char, std::char_traits > > >, std::basic_string_view<char, std::char_traits >, false>::operator()(absl::strings_internal::Splitter<absl::ByChar, absl::SkipEmpty, std::basic_string_view<char, std::char_traits > > const&) const': print_configuration_main.cc:(.text.ZNK4absl16strings_internal8SplitterINS_6ByCharENS_9SkipEmptyESt17basic_string_viewIcSt11char_traitsIcEEE18ConvertToContainerISt6vectorIS7_SaIS7_EES7_Lb0EEclERKS8[ZNK4absl16strings_internal8SplitterINS_6ByCharENS_9SkipEmptyESt17basic_string_viewIcSt11char_traitsIcEEE18ConvertToContainerISt6vectorIS7_SaIS7_EES7_Lb0EEclERKS8]+0xc8): undefined reference to absl::ByChar::Find(std::basic_string_view<char, std::char_traits >, unsigned long) const' print_configuration_main.cc:(.text.ZNK4absl16strings_internal8SplitterINS_6ByCharENS_9SkipEmptyESt17basic_string_viewIcSt11char_traitsIcEEE18ConvertToContainerISt6vectorIS7_SaIS7_EES7_Lb0EEclERKS8[ZNK4absl16strings_internal8SplitterINS_6ByCharENS_9SkipEmptyESt17basic_string_viewIcSt11char_traitsIcEEE18ConvertToContainerISt6vectorIS7_SaIS7_EES7_Lb0EEclERKS8]+0x194): undefined reference to absl::ByChar::Find(std::basic_string_view<char, std::char_traits >, unsigned long) const' collect2: error: ld returned 1 exit status CMakeFiles/cartographer_print_configuration.dir/build.make:153: recipe for target 'cartographer_print_configuration' failed make[2]: *** [cartographer_print_configuration] Error 1 CMakeFiles/Makefile2:421: recipe for target 'CMakeFiles/cartographer_print_configuration.dir/all' failed make[1]: *** [CMakeFiles/cartographer_print_configuration.dir/all] Error 2 make[1]: *** Waiting for unfinished jobs.... libcartographer.a(histogram.cc.o): In function cartographer::common::Histogram::ToStringabi:cxx11 const': histogram.cc:(.text+0x310): undefined reference to absl::strings_internal::CatPieces[abi:cxx11](std::initializer_list<std::basic_string_view<char, std::char_traits > >)' histogram.cc:(.text+0x778): undefined reference to `absl::strings_internal::AppendPieces(std::__cxx11::basic_string<char, std::char_traits, std::allocator >*, std::initializer_list<std::basic_string_view<char, std::char_traits > >)' collect2: error: ld returned 1 exit status CMakeFiles/cartographer_pbstream.dir/build.make:153: recipe for target 'cartographer_pbstream' failed make[2]: *** [cartographer_pbstream] Error 1 CMakeFiles/Makefile2:395: recipe for target 'CMakeFiles/cartographer_pbstream.dir/all' failed

    Help! I have met the same problem, even if I did it as "Confirmed on my end: if I add back what was removed from AbseilConfigureCopts.make in commit https://github.com/abseil/abseil-cpp/commit/c6954897f7ece5011f0126db9117361dc1a6ff36 then it works."

  • Make endian.h more constexpr

    Make endian.h more constexpr

    This is a suggestion to make absl/base/internal/endian.h more constexpr. If the feature test macro __cpp_lib_byteswap is present then std::byteswap (which is already constexpr) can be used instead of the compiler builtins (e.g. __builtin_bswap64 and whatnot). If __cpp_lib_byteswap is not present then it's still possible to implement a constexpr byte swap using only C++11 features (and Clang/GCC should still emit code that use the bswap instruction for runtime calls), see https://stackoverflow.com/a/36937049/7897084 . By doing this all the gbswap* functions can be marked constexpr.

    Likewise the other utility functions defined in endian.h that just call byte swap routines (e.g. the ToHost* and FromHost* functions) can also be marked constexpr.

    Tangentially related, absl/base/config.h should consider using std::endian from C++20 if available (feature test macro __cpp_lib_endian) to check for system endianness instead of the compiler builtins.

  • Inconsistency between find and traversing with iterators

    Inconsistency between find and traversing with iterators

    Hi all; I recently replaced the hash tables in my code with abseil hash. I notice the following abnormal behavior in some of my tests. I look up for an element with find and it is saying is not there then I print all key values in the container and I see the element being actually present.

          typedef absl::flat_hash_map<H/*hashCode*/, I/*indexIntoColumn*/ 
               , absl::container_internal::hash_default_hash<H> 
               , absl::container_internal::hash_default_eq<H> 
               , Allocator<std::pair<const H, I>> // Our own Allocator
               > map_t;
    
            auto hit = hashIndexA.map.find(hashCode);
            if (hit == hashIndexA.map.end()) {
                cout<<&hashIndexA<<&(hashIndexA.map)<<"::element not found:"<<hashCode<<"\n";
                for (auto mit = hashIndexA.begin(); mit != hashIndexA.end();++mit)
                    cout<<"HASHINDEX:"<<mit->first<<"::"<<mit->second<<"\n";
            }
    
    sample output:
    0xffff62a2d0d00xffff62a2d128::element not found:-1574725910
    HASHINDEX:-1574725910::2
    HASHINDEX:-1574733349::5
    

    This is with C++11, Abseil-lts_2020_09_23 and the only maybe special thing here is that the map is created in one thread and potentially read in a separate thread . There is no concurrent access. The table is completely created by one thread and later on the other thread is is reading the data.

    Maybe by luck , when replacing the default hashing function with std::hash my tests are passing. Also the tests always pass in debug mode. The issue is only present in -g -O2 mode.

    I was wondering if anybody else hit this issue in the past and if there are any flags that can be set ?

    Are there any thread local storage issues that may affect the behavior in my scenario ?

    Unfortunately I don;t have an individual reproducer. For me these are hundred of complex tests doing joins, distinct, group by in the context of a database.

  • Why not mention that parse.h should be included when using ParseCommandLine()

    Why not mention that parse.h should be included when using ParseCommandLine()

    On this page, in the parsing flags during startup section, a code snippet was provided for absl::ParseCommandLine(argc,argv). I'm kind of dumb so it took me a while to figure out I also needed to use #include "absl/flags/parse.h"

  • ABSL_FLAG macro triggers abseil-no-namespace check

    ABSL_FLAG macro triggers abseil-no-namespace check

    Describe the bug

    ABSL_FLAG triggers clang-tidy abseil-no-namespace check

    Steps to reproduce the bug

    $ cat main.cc

    #include "absl/flags/flag.h"
    #include "absl/flags/parse.h"
    
    ABSL_FLAG(std::string, input, "input", "input file path");
    
    int main(int argc, char* argv[]) {
      absl::ParseCommandLine(argc, argv);
    
      return EXIT_SUCCESS;
    }
    

    clang-tidy --checks=abseil-* main.cc

    main.cc:7:1: error: namespace 'absl' is reserved for implementation of the Abseil library and should not be opened in user code [abseil-no-namespace,-warnings-as-errors]
    ABSL_FLAG(std::string, input, "input", "input file path");
    ^
    external/com_google_absl/absl/flags/flag.h:166:3: note: expanded from macro 'ABSL_FLAG'
      ABSL_FLAG_IMPL(Type, name, default_value, help)
      ^
    external/com_google_absl/absl/flags/flag.h:269:13: note: expanded from macro 'ABSL_FLAG_IMPL'
      namespace absl /* block flags in namespaces */ {}                           \
                ^
    

    What version of Abseil are you using?

    f3489c9ca64e0fad2a263e8560ee96718ac8b21b

    What operating system and version are you using

    Ubuntu 18.04

    What compiler and version are you using?

    clang-tidy-13

    What build system are you using?

    bazel 4.2.2

Concise CMake templates for creating C++ libraries or executables.

cmake_templates Concise cmake templates for creating C++ libraries and executables. Creating a normal cmake project Copy the chosen project template s

Apr 28, 2022
Abseil Common Libraries (C++)

The repository contains the Abseil C++ library code. Abseil is an open-source collection of C++ code (compliant to C++11) designed to augment the C++ standard library.

Jun 14, 2022
Single-header C11 port of abseil.io's Swiss Table

cwisstable.h cwisstable is a single-header C11 port of the Abseil project's Swiss Tables. This project is intended to bring the proven performance and

Jun 10, 2022
A library with common code used by libraries and tools around the libimobiledevice project

libimobiledevice-glue Library with common code used by the libraries and tools around the libimobiledevice project. Features The main functionality pr

Jun 9, 2022
POCO C++ Libraries are powerful cross-platform C++ libraries for building network
POCO C++ Libraries are powerful cross-platform C++ libraries for building network

The POCO C++ Libraries are powerful cross-platform C++ libraries for building network- and internet-based applications that run on desktop, server, mobile, IoT, and embedded systems.

Jun 21, 2022
Bolt is a C++ template library optimized for GPUs. Bolt provides high-performance library implementations for common algorithms such as scan, reduce, transform, and sort.

Bolt is a C++ template library optimized for heterogeneous computing. Bolt is designed to provide high-performance library implementations for common

Jun 17, 2022
C++ (with python bindings) library for easily reading/writing/manipulating common animation particle formats such as PDB, BGEO, PTC. See the discussion group @ http://groups.google.com/group/partio-discuss

Partio - A library for particle IO and manipulation This is the initial source code release of partio a tool we used for particle reading/writing. It

Jun 20, 2022
Wangle is a framework providing a set of common client/server abstractions for building services in a consistent, modular, and composable way.

Wangle C++ networking library Wangle is a library that makes it easy to build protocols, application clients, and application servers. It's like Netty

Jun 17, 2022
🔗 Common Data Structures and Algorithms

?? Data Structures and Algorithms This library provides common data structures. It will also provide some data structures which needed in render or ga

Jan 28, 2022
The libxo library allows an application to generate text, XML, JSON, and HTML output using a common set of function calls. The application decides at run time which output style should be produced.

libxo libxo - A Library for Generating Text, XML, JSON, and HTML Output The libxo library allows an application to generate text, XML, JSON, and HTML

Jun 13, 2022
Utilities and common code for use with raylib

Utilities and shared components for use with raylib

Jun 15, 2022
A library of common data structures and algorithms written in C.

C Algorithms The C programming language includes a very limited standard library in comparison to other modern programming languages. This is a coll

Jun 17, 2022
Common Lisp and CXX interoperation with JIT
Common Lisp and CXX interoperation  with JIT

CL-CXX-JIT - Common Lisp C++ JIT for exposing C++ functions This library provides an interface to C++ from lisp. It compiles C++ code, then loads it i

May 19, 2022
Common Sensor API for the BMA2 family of sensors

BMA2 Sensor API Sensor overview The BMA2 is a triaxial, low-g acceleration sensor with digital output. An ASIC in the sensor converts the output of a

Sep 12, 2021
Common utilities useful for embedded systems that are often not included in an RTOS or the standard C library.
Common utilities useful for embedded systems that are often not included in an RTOS or the standard C library.

Welcome to Fitterbap, the Firmware toolkit to enable reliable best architecture practices! Fitterbap provides common utilities useful for embedded systems that are often not included in an RTOS or the standard C library.

Apr 2, 2022
A fast Python Common substrings of multiple strings library with C++ implementation

A fast Python Common substrings of multiple strings library with C++ implementation Having a bunch of strings, can I print some substrings which appea

Sep 14, 2021
Common Device Source For Xiaomi Redmi Note 5 Pro (whyred)

The Redmi Note 5 Pro (codenamed "whyred") are high-end mid-range smartphones from Xiaomi announced and released in February 2018. Device specification

Dec 22, 2021
Isaac ROS common utilities and scripts for use in conjunction with the Isaac ROS suite of packages.

Isaac ROS Common Isaac ROS common utilities and scripts for use in conjunction with the Isaac ROS suite of packages. Docker Scripts run_dev.sh creates

Jun 10, 2022
A static analysis tool that helps security researchers scan a list of Windows kernel drivers for common vulnerability patterns in drivers (CVE makers!)
A static analysis tool that helps security researchers scan a list of Windows kernel drivers for common vulnerability patterns in drivers (CVE makers!)

Driver Analyzer A static analysis tool that helps security researchers scan a list of Windows kernel drivers for common vulnerability patterns in driv

Jun 13, 2022
Clio is an embryonic experiment in UI for Common Lisp programs.

Clio Clio is an embryonic experiment in UI for Common Lisp programs. Building and running Clio Make sure you have the prerequisites: Visual Studio 201

Feb 26, 2022