A collection of third party libraries compiled for x86 and/or x64 assembler. Also includes original created libraries or sourced (pre-compiled) libraries which have include files (included, created or generated) for Masm, Uasm or other assemblers. Some of the attached library zip files (or links to downloads) may also include .api files for RadASM for Masm and/or Uasm.
Note: Some of the libraries will require the Windows 10 Universal C Runtime (CRT): https://www.microsoft.com/en-us/download/details.aspx?id=48234 (https://www.microsoft.com/en-us/download/details.aspx?id=48234)
See also: https://devblogs.microsoft.com/cppblog/introducing-the-universal-crt/ (https://devblogs.microsoft.com/cppblog/introducing-the-universal-crt/)
Compression:- APLib 1.1.1 (https://masm32.com/board/index.php?msg=124914)
- BriefLZ 1.3.0 (https://masm32.com/board/index.php?msg=125093)
- Brotli 1.1.0 (https://masm32.com/board/index.php?msg=125490)
- Bzip2 1.1.0 (https://masm32.com/board/index.php?msg=124996)
- Bzip3 1.3.0 (https://masm32.com/board/index.php?msg=125492)
- FastLZ 0.5.0 (https://masm32.com/board/index.php?msg=125493)
- FSE 0.9.0 (https://masm32.com/board/index.php?msg=125047)
- JCALG1 r5.xx (https://masm32.com/board/index.php?msg=124926)
- Lizard 1.0 (https://masm32.com/board/index.php?msg=125494)
- LZ4 1.9.5 (https://masm32.com/board/index.php?msg=124915)
- LZAV 2.15 (https://masm32.com/board/index.php?msg=126108)
- LZFSE (https://masm32.com/board/index.php?msg=126107)
- Lzma (https://masm32.com/board/index.php?topic=12075.0)
- Snappy 1.1.10 (https://masm32.com/board/index.php?msg=124916)
- Zlib 1.3.1 (https://masm32.com/board/index.php?msg=126500)
- Zstd 1.5.5 (https://masm32.com/board/index.php?msg=124919)
Database:- LMDB 0.9.70 (Key-value) (https://masm32.com/board/index.php?msg=126617)
- SQLite 3.47 (RDBMS) (https://masm32.com/board/index.php?msg=134575)
Data Exchange/Serialization:- cJSON 1.7.16 (JSON) (https://masm32.com/board/index.php?msg=124960)
- Jansson 2.14 (JSON) (https://masm32.com/board/index.php?msg=124942)
- Mini-XML 3.3.1 (XML) (https://masm32.com/board/index.php?msg=124941)
Image Handling:- PNGlib 1.0 (https://masm32.com/board/index.php?msg=124966)
- GIFLIB 1.0 (https://masm32.com/board/index.php?msg=126563)
- PlutoSVG 0.0.2 (https://masm32.com/board/index.php?msg=134272)
- PlutoVG 0.0.8 (https://masm32.com/board/index.php?msg=134272)
Mathematics:- FpuLib 2.341 (Floating Point Math) (https://masm32.com/board/index.php?msg=124930)
- MixLib 1.0 (Fixed Point Math) (https://masm32.com/board/index.php?msg=124931)
- ZLIB 1.1 (Complex Numbers) (https://masm32.com/board/index.php?msg=124924)
aPLib: https://ibsensoftware.com/products_aPLib.html (https://ibsensoftware.com/products_aPLib.html)
QuoteaPLib is a compression library based on the algorithm used in aPACK (my executable compressor). aPLib is an easy-to-use alternative to many of the heavy-weight compression libraries available.
The compression ratios achieved by aPLib combined with the speed and tiny footprint of the depackers (as low as 169 bytes!) makes it the ideal choice for many products.
Since the first public release in 1998, aPLib has been one of the top pure LZ-based compression libraries available. It is used in a wide range of products including executable compression and protection software, archivers, games, embedded systems, and handheld devices.
LZ4: https://github.com/lz4/lz4 (https://github.com/lz4/lz4)
QuoteExtremely Fast Compression algorithm.
LZ4 is lossless compression algorithm, providing compression speed > 500 MB/s per core, scalable with multi-cores CPU. It features an extremely fast decoder, with speed in multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
Speed can be tuned dynamically, selecting an "acceleration" factor which trades compression ratio for faster speed. On the other end, a high compression derivative, LZ4_HC, is also provided, trading CPU time for improved compression ratio. All versions feature the same decompression speed.
Snappy: https://github.com/google/snappy (https://github.com/google/snappy)
QuoteA fast compressor/decompressor
Snappy is a compression/decompression library. It does not aim for maximum compression, or compatibility with any other compression library; instead, it aims for very high speeds and reasonable compression. For instance, compared to the fastest mode of zlib, Snappy is an order of magnitude faster for most inputs, but the resulting compressed files are anywhere from 20% to 100% bigger.
Zlib: https://zlib.net/ - https://github.com/madler/zlib (https://zlib.net/%20-%20https://github.com/madler/zlib)
QuoteA massively spiffy yet delicately unobtrusive compression library
Zstandard: https://facebook.github.io/zstd/ - https://github.com/facebook/zstd (https://facebook.github.io/zstd/%20-%20https://github.com/facebook/zstd)
QuoteZstandard is a real-time compression algorithm, providing high compression ratios.
Note: attached are rar archives to fit the post limit
Quote from: fearless on November 03, 2023, 09:14:36 PMaPLib: https://ibsensoftware.com/products_aPLib.html (https://ibsensoftware.com/products_aPLib.html)
Quote from: hutch-- on May 13, 2012, 10:57:54 PMHave a look at Jibz's aPlib library, its written in C but it does work well and you can link it directly into an executable.
Unzip (https://www.jj2007.eu/MasmBasicQuickReference.htm#Mb1389) uses the ApLib since 2012 or so. The tinf.lib is 3,662 bytes short. Great stuff from Jørgen Ibsen :thumbsup:
Quote from: fearless on November 03, 2023, 09:16:57 PMZlib: https://zlib.net/ - https://github.com/madler/zlib
QuoteA massively spiffy yet delicately unobtrusive compression library
I only hope it does not ever get mixed up with the zlib issued many years ago to the masm32 community and related to functions of complex numbers. http://www.ray.masmcode.com/complex.html (http://www.ray.masmcode.com/complex.html)
Hi fearless
Thank you for sharing your work. It's truly appreciated. :thumbsup:
Biterider
Jeremy Collake's JCALG1 – Compression Library :
QuoteNOTICE: This is a legacy project originating 20 years ago.
JCALG1 is a lossless compression algorithm loosely based on LZSS. It is written entirely in x86 assembly. It compresses very well, though is slow to compress. Decompression is as rapid as any other LZ77 derivative. It has a unique ability to handle pre-compressed or high entropy data.
Credits: Joergen Ibsen, author of apLib, was instrumental during this algorithm's development. Much of the encoding is similar to that of apLib.
Synopsis: JCALG1 is a small, open-source, LZSS derived compression library.
Features:
Written in 100% 32-bit x86 assembly language for reasons that made sense at the time.
Good compression ratio, typically much better than ZIP's deflate.
Extremely small and fast decompressor.
Adjustable window size to allow for faster compression at the cost of compression ratio.
Decompression requires no additional memory (other than output buffer).
Easy integration with any application.
Free!
https://bitsum.com/portfolio/jcalg1/ (https://bitsum.com/portfolio/jcalg1/)
Attached is a simple SFX example built with JCALG1 and Hutch's File Data Assembler.
.386
.model flat,stdcall
option casemap:none
extractfile PROTO :DWORD, :DWORD, :DWORD
JCALG1_Decompress_Fast PROTO :DWORD, :DWORD
JCALG1_GetUncompressedSizeOfCompressedBlock PROTO :DWORD
EXTERN pData:BYTE
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\user32.lib
.data
file db 'Sample.exe',0
msg db 'Sample.exe extracted to disc',0
capt db 'JCALG1 library',0
.data?
hMem dd ?
fSize dd ?
hFile dd ?
size1 dd ?
.code
start:
invoke JCALG1_GetUncompressedSizeOfCompressedBlock,\
ADDR pData
mov fSize,eax
invoke VirtualAlloc,0,eax,\
MEM_COMMIT,PAGE_READWRITE
mov hMem,eax
invoke JCALG1_Decompress_Fast,ADDR pData,eax
xor eax,eax
invoke CreateFile,ADDR file,GENERIC_WRITE,\
eax,eax,CREATE_ALWAYS,eax,eax
mov hFile,eax
invoke WriteFile,eax,hMem,fSize,ADDR size1,0
invoke CloseHandle,hFile
invoke VirtualFree,hMem,0,MEM_RELEASE
invoke MessageBox,0,ADDR msg,ADDR capt,MB_OK
invoke ExitProcess,0
END start
Hi Vortex!
Quote from: Vortex on November 04, 2023, 05:05:45 AMSFX example built with JCALG
Can extracted file overwrite the "SFX" in Windows?
If I remember well, that worked in DOS, perhaps early Windows versions, not so sure.
HSE
Hi HSE,
The extracted file does not touch the main SFX archive, it's not supposed to do this. If you are mentioning about an overlay data connected to a SFX stub, that's possible :
SFX stub for cab archives (https://masm32.com/board/index.php?topic=2291.0)
Quote from: Vortex on November 04, 2023, 06:50:27 AMThe extracted file does not touch the main SFX archive, it's not supposed to do this.
Ok. :thumbsup:
Quote from: Vortex on November 04, 2023, 06:50:27 AMIf you are mentioning about an overlay data connected to a SFX stub, that's possible :
SFX stub for cab archives (https://masm32.com/board/index.php?topic=2291.0)
Could be something like that, but from commandline. Most probable, SFX was called from a diferent directory. That last work perfectly with example, I see now.
Thanks
FpuLib: http://www.ray.masmcode.com/fpu.html#fpulib (http://www.ray.masmcode.com/fpu.html#fpulib)
QuoteThe library consists of the usual arithmetic, trigonometric, hyperbolic, logarithmic and exponential functions. The ASCII-to-float and float-to-ASCII conversion functions are also available in addition to a few other general purpose functions.
Copyright Raymond Filiatreault 2002 - 2010
MixLib: http://www.ray.masmcode.com/fixmath.html (http://www.ray.masmcode.com/fixmath.html)
QuoteA library of functions for fixed point math
March 2005 by Raymond Filiatreault
Mini-XML: https://www.msweet.org/mxml/ (https://www.msweet.org/mxml/)
QuoteMini-XML is a tiny XML library that you can use to read and write XML and XML-like data files in your application without requiring large non-standard libraries.
Mini-XML provides the following functionality:
- Reading of UTF-8 and UTF-16 and writing of UTF-8 encoded XML files and strings.
- Data is stored in a linked-list tree structure, preserving the XML data hierarchy.
- SAX (streamed) reading of XML files and strings to minimize memory usage.
- Supports arbitrary element names, attributes, and attribute values with no preset limits, just available memory.
- Supports integer, real, opaque ("cdata"), and text data types in "leaf" nodes.
- Functions for creating and managing trees of data.
- "Find" and "walk" functions for easily locating and navigating trees of data.
Jansson: http://www.digip.org/jansson/ (http://www.digip.org/jansson/) - https://github.com/akheron/jansson (https://github.com/akheron/jansson)
QuoteJansson is a C library for encoding, decoding and manipulating JSON data. Its main features and design principles are:
- Simple and intuitive API and data model
- Comprehensive documentation
- No dependencies on other libraries
- Full Unicode support (UTF-8)
- Extensive test suite
cJSON: https://github.com/DaveGamble/cJSON (https://github.com/DaveGamble/cJSON)
QuoteUltralightweight JSON parser in ANSI C
Request: do you by any chance have a library that can handle images (JPG, PNG, etc.)? Ideally using GDI instead of GDI+? Need to be able to open, save, display and resize images.
Quote from: NoCforMe on November 06, 2023, 04:16:56 AMlibrary that can handle images (JPG, PNG, etc.)?
Hi
For some time now, the operating system has a component called ImgCtx. It can be interfaced via COM and it can handle (BitBlt, stretch and alpha operations) BMP, GIF, JPEG, ICO, WMF, EMF, PNG, XBM, ICO, TIFF.
Here is an example where you can check what it can do
https://github.com/ObjAsm/ObjAsm-C.2/blob/master/Projects/X/Image/ImageApp.exe (https://github.com/ObjAsm/ObjAsm-C.2/blob/master/Projects/X/Image/ImageApp.exe)
Biterider
Ugh, COM. Never used it. Can you tell me, in a nutshell, what it takes to incorporate COM into a Win32 program? It seems like a big, ugly, scary interface to me.
PNGLib: https://www.madwizard.org/programming/projects/pnglib (https://www.madwizard.org/programming/projects/pnglib)
QuoteA free PNG decoder library
This library allows you to decode and display PNG images in your applications. The library is very small and has been written in assembly (MASM32). The library supports both interlaced and non-interlaced PNGs, in all color types mentioned in the PNG specifications version 1.0. The library is easy to use, has detailed documentation. Includes and headers are supplied for use with MASM32 and Visual C.
Several code samples (MASM32 and Visual C) are included as well, one of them is the PNGview program: a 30kb PNG viewer, written in C using the PNGlib.
PNG files are designed to be patent-free, so no licenses or fees of any kind are required to use this library. The library itself is free as well, however for commercial use, please contact me first to ask permission (see the license in the documentation for more information). Usually this is no problem.
Hi
In the internet you can find a lot of references on how to use this component.
For myself I use https://github.com/ObjAsm/ObjAsm-C.2/blob/master/Code/Objects/Image.inc (https://github.com/ObjAsm/ObjAsm-C.2/blob/master/Code/Objects/Image.inc)
The MASM SDK defines some macros to handle COM calls (look for coinvoke) in plain MASM.
A very good intro into COM can be read here https://www.codeproject.com/Articles/13601/COM-in-plain-C (https://www.codeproject.com/Articles/13601/COM-in-plain-C)
Regards, Biterider
Bzip2: https://sourceware.org/bzip2/ (https://sourceware.org/bzip2/) - https://gitlab.com/bzip2/bzip2 (https://gitlab.com/bzip2/bzip2)
Quotebzip2 is a freely available, patent free (see below), high-quality data compressor. It typically compresses files to within 10% to 15% of the best available techniques (the PPM family of statistical compressors), whilst being around twice as fast at compression and six times faster at decompression.
FSE (Finite State Entropy): https://github.com/Cyan4973/FiniteStateEntropy (https://github.com/Cyan4973/FiniteStateEntropy)
QuoteNew generation entropy codecs : Finite State Entropy and Huff0
This library proposes two high speed entropy coders :
Huff0, a Huffman codec designed for modern CPU, featuring OoO (Out of Order) operations on multiple ALU (Arithmetic Logic Unit), achieving extremely fast compression and decompression speeds.
FSE is a new kind of Entropy encoder, based on ANS theory, from Jarek Duda, achieving precise compression accuracy (like Arithmetic coding) at much higher speeds.
BriefLZ: https://github.com/jibsen/brieflz (https://github.com/jibsen/brieflz)
QuoteBriefLZ is a small and fast open source implementation of a Lempel-Ziv style compression algorithm. The main focus is on speed and code footprint, but the ratios achieved are quite good compared to similar algorithms.
Brotli: https://github.com/google/brotli (https://github.com/google/brotli) (x86)
QuoteBrotli is a generic-purpose lossless compression algorithm that compresses data using a combination of a modern variant of the LZ77 algorithm, Huffman coding and 2nd order context modeling, with a compression ratio comparable to the best currently available general-purpose compression methods. It is similar in speed with deflate but offers more dense compression.
Brotli: https://github.com/google/brotli (https://github.com/google/brotli) (x64)
QuoteBrotli is a generic-purpose lossless compression algorithm that compresses data using a combination of a modern variant of the LZ77 algorithm, Huffman coding and 2nd order context modeling, with a compression ratio comparable to the best currently available general-purpose compression methods. It is similar in speed with deflate but offers more dense compression.
BZip3: https://github.com/kspalaiologos/bzip3 (https://github.com/kspalaiologos/bzip3)
QuoteBZip3 - A spiritual successor to BZip2.
A better, faster and stronger spiritual successor to BZip2. Features higher compression ratios and better performance thanks to a order-0 context mixing entropy coder, a fast Burrows-Wheeler transform code making use of suffix arrays and a RLE with Lempel Ziv+Prediction pass based on LZ77-style string matching and PPM-style context modeling.
FastLZ: https://github.com/ariya/FastLZ (https://github.com/ariya/FastLZ)
QuoteSmall & portable byte-aligned LZ77 compression.
FastLZ (MIT license) is an ANSI C/C90 implementation of Lempel-Ziv 77 algorithm (LZ77) of lossless data compression. It is suitable to compress series of text/paragraphs, sequences of raw pixel data, or any other blocks of data with lots of repetition. It is not intended to be used on images, videos, and other formats of data typically already in an optimal compressed form.
The focus for FastLZ is a very fast compression and decompression, doing that at the cost of the compression ratio.
Lizard: https://github.com/inikep/lizard (https://github.com/inikep/lizard)
QuoteLizard (formerly LZ5) is an efficient compressor with very fast decompression. It achieves compression ratio that is comparable to zip/zlib and zstd/brotli
Lizard library is based on frequently used LZ4 library by Yann Collet but the Lizard compression format is not compatible with LZ4.
Lots of good stuff, fearless :thumbsup:
One problem I see is that most if not all of these projects just care for the raw compression, not for creating e.g. a zip archive that is readable by other archivers.
Thanks.
Yes most are raw compression. One I came across that might do what you want it Miniz: https://github.com/richgel999/miniz (https://github.com/richgel999/miniz)
The version (2.1.0) I have is older (about 4 years ago) than the current release of 3.0.2. I haven't done any testing on it or the older one tbh, so don't know if there are any issues.
I managed to compile the newer ones and the include files for the older version might be workable (Miniz_302_Libs.zip contains the newer v3.02 of the Miniz for x86 and x64). Anyhow attached is the v2.1.0 of Miniz for x86 and x64 as well.
TLWHViewRE had reduced MiniZ code for unpacking help files.
A very interesting recent article about compression in general and zstandard in particular (https://gregoryszorc.com/blog/2017/03/07/better-compression-with-zstandard/)
(https://gregoryszorc.com/images/compression-bundle-multithreaded.png)
LZFSE: https://github.com/lzfse/lzfse (https://github.com/lzfse/lzfse)
QuoteLZFSE by Apple is a Lempel-Ziv style data compression algorithm using Finite State Entropy coding. It targets similar compression rates at higher compression and decompression speed compared to deflate using zlib.
LZAV: https://github.com/avaneev/lzav (https://github.com/avaneev/lzav)
QuoteFast In-Memory Data Compression Algorithm
LZAV is a fast general-purpose in-memory data compression algorithm based on now-classic LZ77 lossless data compression method. LZAV holds a good position on the Pareto landscape of factors, among many similar in-memory (non-streaming) compression algorithms.
Quote from: fearless on January 02, 2024, 07:27:22 AMLZAV
POLINK: fatal error: File not found: 'LIBCMT.lib'
When I copy the two DLLs required to the current folder, it assembles and runs, but...
Let esi=FileRead$("\Masm32\include\Windows.inc")
mov eax, LastFileSize
lea ecx, [4*eax] ; let's be very generous
Let edi=New$(ecx)
invoke lzav_compress_default, esi, edi, ecx, LastFileSize... returns zero.
Usage Information (https://github.com/avaneev/lzav)
To compress data:
#include "lzav.h"
int max_len = lzav_compress_bound( src_len );
void* comp_buf = malloc( max_len ); // Or similar.
int comp_len = lzav_compress_default( src_buf, comp_buf, src_len, max_len );
if( comp_len == 0 && src_len != 0 )
{
// Error handling.
}
Attached is a radasm test project for LZAV, I add 128 to the compressbound value before allocating the mem just in case. I dont get that linker error. Im using the microsoft linker tho, and the vcruntime and ucrt libs are from the visual studio 2022 installation i think.
Quote from: jj2007 on January 02, 2024, 08:51:22 AM Let esi=FileRead$("\Masm32\include\Windows.inc")
mov eax, LastFileSize
lea ecx, [4*eax] ; let's be very generous
Let edi=New$(ecx)
invoke lzav_compress_default, esi, edi, ecx, LastFileSize
Don't you have those last two parameters reversed?
Quoteint comp_len = lzav_compress_default( src_buf, comp_buf, src_len, max_len );
Not sure that would make any difference ...
Quote from: NoCforMe on January 02, 2024, 03:51:01 PMDon't you have those last two parameters reversed?
You are absolutely right - my bad :sad:
And it works now, like a charm!
include \masm32\MasmBasic\MasmBasic.inc
include LZAV_x86.inc
includelib LZAV_x86.lib
Init
Let esi=FileRead$("\Masm32\include\Windows.inc")
imul ecx, LastFileSize, 17
sar ecx, 4
Let edi=New$(ecx) ; filesize*17/16
push ecx
invoke lzav_compress_default, esi, edi, LastFileSize, ecx
pop ecx
deb 4, "compress ", eax
.if eax
push LastFileSize
FileWrite "test.lza", edi, eax
Let esi=FileRead$("test.lza")
pop eax
invoke lzav_decompress, esi, edi, LastFileSize, eax
deb 4, "decompress", eax
.if signed eax>0
FileWrite "test.txt", edi, eax
.endif
.endif
EndOfCodeThe docs are a bit cryptic:
Quote* @param[in] src Source (uncompressed) data pointer, can be 0 if srcl==0.
* Address alignment is unimportant.
* @param[out] dst Destination (compressed data) buffer pointer. The allocated
* size should be at least lzav_compress_bound() bytes large. Address
* alignment is unimportant. Should be different to src.
* @param srcl Source data length, in bytes, can be 0: in this case the
* compressed length is assumed to be 0 as well.
* @param dstl Destination buffer's capacity, in bytes.
* @param ext_buf External buffer to use for hash-table, set to 0 for the
* function to manage memory itself (via std malloc). Supplying a
* pre-allocated buffer is useful if compression is performed during
* application's operation often: this reduces memory allocation overhead and
* fragmentation. Note that the access to the supplied buffer is not
* implicitly thread-safe.
* @param ext_bufl The capacity of the ext_buf, in bytes, should be a
* power-of-2 value. Set to 0 if ext_buf is 0. The capacity should not be
* lesser than 4*srcl, not lesser than 256, but not greater than 1
* MiB. Same ext_bufl value can be used for any smaller sources.
* @return The length of compressed data, in bytes. Returns 0 if srcl<=0, or
* if dstl is too small, or if not enough memory.
I couldn't see any difference between the default option and one that does supply that buffer.
if 1
Let ebx=New$(524288)
invoke lzav_compress, esi, edi, LastFileSize, ecx, ebx, 524288
deb 4, "compress A", eax
else
invoke lzav_compress_default, esi, edi, LastFileSize, ecx
deb 4, "compress B", eax
endif
SQLite: https://www.sqlite.org (https://www.sqlite.org/)
QuoteSQLite is a C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine
(Note: too large to attach to post, but they are uploaded to my github libraries repo)
https://github.com/mrfearless/libraries/blob/master/releases/sqlite3_x86.zip?raw=true (https://github.com/mrfearless/libraries/blob/master/releases/sqlite3_x86.zip?raw=true)
https://github.com/mrfearless/libraries/blob/master/releases/sqlite3_x64.zip?raw=true (https://github.com/mrfearless/libraries/blob/master/releases/sqlite3_x64.zip?raw=true)
Zlib 1.3.1: https://zlib.net/ - https://github.com/madler/zlib (https://zlib.net/%20-%20https://github.com/madler/zlib)
QuoteA massively spiffy yet delicately unobtrusive compression library
GIFLIB v1.0 (revision 2): https://www.madwizard.org/programming/toolarchive (https://www.madwizard.org/programming/toolarchive)
QuoteGIFLIB is an easy to use library that enables you to use the GIF file format in your programs. It comes as a static library which can be linked to your program. GIFLIB is very small.
https://www.madwizard.org/download/GIFLIB.zip (https://www.madwizard.org/download/GIFLIB.zip)
LMDB 0.9.70 - https://www.symas.com/lmdb (https://www.symas.com/lmdb)
QuoteSymas LMDB is an extraordinarily fast, memory-efficient database we developed for the OpenLDAP Project. With memory-mapped files, LMDB has the read performance of a pure in-memory database while retaining the persistence of standard disk-based databases.
https://github.com/LMDB/lmdb (https://github.com/LMDB/lmdb)
http://www.lmdb.tech/doc/group__mdb.html (http://www.lmdb.tech/doc/group__mdb.html)
https://blogs.kolabnow.com/2018/06/07/a-short-guide-to-lmdb (https://blogs.kolabnow.com/2018/06/07/a-short-guide-to-lmdb)
PlutoSVG 0.0.2: https://github.com/sammycage/plutosvg (https://github.com/sammycage/plutosvg)
PlutoVG 0.0.8: https://github.com/sammycage/plutovg (https://github.com/sammycage/plutovg)
QuotePlutoSVG is a Tiny SVG rendering library in C.
QuotePlutoVG is a Tiny 2D vector graphics library in C.
Both libraries are included in the attached archives.
x86 test/example for plutosvg and plutovg
x64 test/example for plutosvg and plutovg
Hi fearless
Interesting stuff. I downloaded the latest demo and it runs fine here.
Thanks for sharing your work :thumbsup:
Biterider
SQLite 3.47: https://www.sqlite.org (https://www.sqlite.org/)
QuoteSQLite is a C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine
(Note: too large to attach to post, but they are uploaded to my github libraries repo)
https://github.com/mrfearless/libraries/blob/master/releases/sqlite3_x86.zip?raw=true (https://github.com/mrfearless/libraries/blob/master/releases/sqlite3_x86.zip?raw=true)
https://github.com/mrfearless/libraries/blob/master/releases/sqlite3_x64.zip?raw=true (https://github.com/mrfearless/libraries/blob/master/releases/sqlite3_x64.zip?raw=true)
Hi fearless
Quote from: fearless on November 08, 2024, 12:51:58 AMSQLite 3.47
Wow, that is the latest version :thumbsup:
Thanks for sharing!
Biterider