rea
Reverse engineer anything with agents, from app behavior down to native binaries.
- 474k
- TypeScript
- MIT
- 1 h ago

A high-performance cross-platform native Library loader API for JVM Applications
Repo Electrostat-Lab/jSnapLoader, read from GitHub 1 min ago. Electrostat-Lab has not joined Take My Repo.
Electrostat-Lab/jSnapLoader is a public repo on GitHub by Electrostat-Lab. A high-performance cross-platform native Library loader API for JVM Applications. It declares the BSD-3-Clause license on GitHub. It is written mainly in Java, has 10 stars and last changed on 2026-10-18. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
A high-performance cross-platform dynamic library loader API for JVM Applications, with highly modifiable system-specific registration using platform predicates.
| Item | Description | Predicate Calculus |
|---|---|---|
| Problem Definition | The main problem that entailed building this project had been to have something similar to the JME's NativeLibraryLoader, but for a better version with more capabilities (such as: loading libraries from external Jars and having a generic file extraction interface). |
Sample = $P = [\cup_{n = 0}^N P_n]$ - Formula (Mapping relations in the form antecedents to descendants) = $\forall{P}\exists{S}\ F(P, S)$ |
| Generalized Approach | The generalized approach was deemed insufficient; as it will not add on the JME's NativeLibraryLoader, and thus the project will be insignificant. The generalized approach entails building something that directly encapsulates concrete buffered byte stream calls to ZipFileSystem interfaces for the native libraries only within the same classpath, and that actually is a bad practice to build APIs on concretions, instead as the Ontology entails, abstractions and using levels of indirections should play the most part in developing a new system. |
Sample = $S = [\cup_{n = 0}^N S_n]$ - Formula (Mapping relations in the form descendants to antecedents) = $\forall{S}\exists{P}\ F(S, P)$ |
| jSnapLoader-specific Approach | The jSnapLoader-specific approach is quite genuine, nevertheless it's not unique. The essential design entails the basic use of the System-Entity-Structure (SES) Framework; which essentially decomposes the the bulky actions of the library, first from the perspective of behavior into deterministic finite-states, and then from the structural perspective into the components that execute these states; the net result is having a freely-floating decomposed components. The next step was regrouping those components (using common properties from predicate calculus) and finding abstractions for them, and finally capturing relations between those components and similar systems (i.e., FileSystem APIs). This structural way of thinking has resulted in the production of beneficial compilation units that could serve other purposes and not entailed specifically to serve native library extraction and loading. | $\forall{P_{loader}}\ \exists{S_{loader}}\ F(P_{loader}, S_{loader})$ |
| Framework Decomposition | The decomposition had been successfully inducted into a FileLocator interface with a validation strategy, a FileExtractor interface with the full ability to control native IO resources, and a LibraryLoader interface with the ability to build and register platform predicates to support any new unsupported systems. |
$$F = \cup_{n = 0}^N \ (P_{loader}, S_{loader})_{n}$$ $$= [(P_{file-locator}, S_{file-locator}), (P_{file-extractor}, S_{file-extractor}),$$ $$(P_{library-locator}, S'_{file-locator}), (P_{library-extractor}, S'_{file-extractor}), (P_{library-loader}, S_{library-loader})]$$ ;where $S'_{clazz}$ S prime represents a solution of class 'clazz'. |
| Common problems, robustness, and re-usability of solutions | To extend the robustness (rigidity) of the solution, multiple similar problems could utilize classes of solutions from the same kind; for instance, the problem library-locator could use a solution of the class file-locator; thus this could be explained by a uniqueness formula as regard to the formal language. |
$$\forall{p}\ \in{P},\ \exists{s} \in{S},\ \forall{s'} \in{S} [(p_{loader}, s_{loader}) \land\ (p_{loader}, s'_{loader})\ \implies\ [s_{loader} = s'_{loader}]$$ |
| Framework Enhancements | The PlatformPredicate interface wasn't planned from the start; it has been added as an enhancement for the library to accomodate the changes and the addition of new platforms robustly without changing the internal API. In fact, I give credits to Jolt-jni for implicitly opening the vision to add them. Furthermore, the addition of the FileLocalizingListener, the FileExtractionListener, and the NativeLibraryLoadingListener binds the user API to the framework API giving jSnapLoader a more added robustness value overtime. |
$$E = \cup_{n = 0}^N \ (E_{loader}, S_{loader})_{n}$$ $$= [(E_{system-detection-listeners}, S_{system-detection-listeners}), (E_{locator-listeners}, S_{locator-listeners}), (E_{extractor-listeners}, S_{extractor-listeners}),$$ $$(E_{loader-listeners}, S_{loader-listeners}), (E_{system-exception}, S_{system-exception})]$$ |
| Credits for other systems | Credits should go for the jSnapLoader's users, Serial4j, Jolt-jni, and Electrostatic4j. Those implicitly and continously have pushed the API over to become better. | --- |
┌─[pavl-machine@pavl-machine]─[/home/twisted/GradleProjects/jSnapLoader] └──╼ $./gradlew clean && \ ./gradlew build && \ ./gradlew :snaploader-examples:run BUILD SUCCESSFUL in 943ms 2 actionable tasks: 2 executed BUILD SUCCESSFUL in 1s 7 actionable tasks: 7 executed BUILD SUCCESSFUL in 1s 4 actionable tasks: 1 executed, 3 up-to-date
┌─[pavl-machine@pavl-machine]─[/home/twisted/GradleProjects/jSnapLoader]
└──╼ $./gradlew :snaploader-examples:TestZipExtractor \
:snaploader-examples:run
BUILD SUCCESSFUL in 1s
4 actionable tasks: 2 executed, 2 up-to-date[build.gradle]
dependencies {
implementation "io.github.electrostat-lab:snaploader:${latest-version}"
}[settings.gradle]
pluginManagement {
repositories {
google()
mavenCentral()
gradlePluginPortal()
}
}
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
google()
mavenCentral()
}
}
...
// project Gradle modules includesLines 44 to 72 in ac841ca
| /** | |
| * Examines the cross-platform capabilities of jSnapLoader. | |
| * | |
| * @author pavl_g. | |
| */ | |
| public class TestCrossPlatformClassPathLoading { | |
| public static void main(String[] args) throws Exception { | |
| final LibraryInfo libraryInfo = new LibraryInfo(new DirectoryPath("lib/independent"), "jmealloc", DirectoryPath.USER_DIR); | |
| final NativeDynamicLibrary[] libraries = new NativeDynamicLibrary[] { | |
| DefaultDynamicLibraries.ANDROID_ALL, | |
| DefaultDynamicLibraries.LINUX_X86, | |
| DefaultDynamicLibraries.LINUX_X86_64, | |
| new NativeDynamicLibrary("lib/windows/x86", "libjmealloc.dll", PlatformPredicate.WIN_X86), | |
| new NativeDynamicLibrary("lib/windows/x86-64", "libjmealloc.dll", PlatformPredicate.WIN_X86_64), | |
| DefaultDynamicLibraries.MAC_X86, | |
| DefaultDynamicLibraries.MAC_X86_64, | |
| }; | |
| final NativeBinaryLoader loader = new NativeBinaryLoader(libraryInfo); | |
| loader.registerNativeLibraries(libraries).initPlatformLibrary(); | |
| loader.setLoggingEnabled(true); | |
| loader.setRetryWithCleanExtraction(true); | |
| /* Native dynamic library properties */ | |
| printDetails(loader); | |
| loader.loadLibrary(LoadingCriterion.INCREMENTAL_LOADING); | |
| } |
basename for the library to be operated, and finally the current working directory as an extraction path.Lines 48 to 82 in ac841ca
| /** | |
| * A finer version of {@link TestBasicFeatures} utilizing the platform-independent | |
| * nio.file APIs. | |
| * | |
| * @author pavl_g | |
| */ | |
| public final class TestBasicFeatures2 { | |
| public static void main(String[] args) throws Exception { | |
| final Path compressionPath = Paths.get(PropertiesProvider.USER_DIR.getSystemProperty(), "libs", TestBasicFeatures.getJarFile()); | |
| final Path extractionPath = Files.createDirectories(Paths.get(PropertiesProvider.USER_DIR.getSystemProperty(), "libs", | |
| NativeVariant.OS_NAME.getProperty(), NativeVariant.OS_ARCH.getProperty())); | |
| final LibraryInfo libraryInfo = new LibraryInfo(new DirectoryPath(compressionPath.toString()), new DirectoryPath("lib/placeholder"), | |
| "jmealloc", new DirectoryPath(extractionPath.toString())); | |
| final NativeDynamicLibrary[] libraries = new NativeDynamicLibrary[] { | |
| DefaultDynamicLibraries.LINUX_X86, | |
| DefaultDynamicLibraries.LINUX_X86_64, | |
| new NativeDynamicLibrary("lib/windows/x86", "libjmealloc.dll", PlatformPredicate.WIN_X86), | |
| new NativeDynamicLibrary("lib/windows/x86-64", "libjmealloc.dll", PlatformPredicate.WIN_X86_64), | |
| DefaultDynamicLibraries.MAC_X86, | |
| DefaultDynamicLibraries.MAC_X86_64, | |
| }; | |
| final NativeBinaryLoader loader = new NativeBinaryLoader(libraryInfo); | |
| loader.registerNativeLibraries(libraries).initPlatformLibrary(); | |
| loader.setLoggingEnabled(true); | |
| loader.setRetryWithCleanExtraction(true); | |
| /* Native dynamic library properties */ | |
| printDetails(loader); | |
| loader.loadLibrary(LoadingCriterion.INCREMENTAL_LOADING); | |
| } |
java.nio.file.Paths and java.nio.file.Path APIs to build platform-independent directory paths, and it's deemed the most superior way, especially for vague systems; thus it's considered the most robust way, and the best cross-platform strategy; because it depends on the Java implementation for this specific runtime.NativeImageLoaderIntroduced in 1.1.1-stable.
Lines 52 to 302 in 3961345
| /** | |
| * A suggested cross-platform algorithm to use fallback mechanisms for Jolt-Jni. | |
| * <p> | |
| * <ul> | |
| * <li> This is an efficient implementation that follows best | |
| * practices for software engineering, and the computational theory. </li> | |
| * <li> This is a theoretical implementation technique. </li> | |
| * <li> Feel free to copy-paste to your projects and modify as required. </li> | |
| * <li> Open issues as required. </li> | |
| * </ul> | |
| * </p> | |
| * | |
| * @author pavl_g. | |
| */ | |
| public class NativeDllLoader implements NativeBinaryLoadingListener, FileLocalizingListener { | |
| /** | |
| * Instance reference for the associated binary loader. | |
| */ | |
| protected final NativeBinaryLoader loader; | |
| /** | |
| * Instance reference for libraries with base features | |
| * for the {@link NativeDllLoader#loadBaseLibraries(LoadingCriterion)} | |
| * as a fallback mechanism. | |
| */ | |
| protected NativeDynamicLibrary[] baseLibs; | |
| /** | |
| * Instance reference for libraries with CPU-based specific features | |
| * for the {@link NativeDllLoader#loadCpuEnhancedLibs(LoadingCriterion)} routine. | |
| */ | |
| protected NativeDynamicLibrary[] cpuEnhancedLibs; | |
| /** | |
| * Instantiates a DLL Loader wrapper setting its logging, retry criteria, | |
| * and setting up its loading listeners. | |
| * | |
| * @param baseLibs the base feature libraries group (not null). | |
| * @param cpuEnhancedLibs the cpu enhanced libraries group (not null). | |
| * @param info the cross-platform library info metadata (not null). | |
| * @param enableLogging true to enable snap-loader logger and failure logs (default: false). | |
| * @param enableRetryCriterion true to enable retrying when loading from a jar file (default: false). | |
| * @throws IllegalArgumentException if the caller stack has passed undefined library groups and/or | |
| * undefined library information reference. | |
| */ | |
| public NativeDllLoader(NativeDynamicLibrary[] baseLibs, NativeDynamicLibrary[] cpuEnhancedLibs, | |
| LibraryInfo info, boolean enableLogging, boolean enableRetryCriterion) { | |
| this(info, enableLogging, enableRetryCriterion); | |
| if (baseLibs == null || cpuEnhancedLibs == null) { | |
| throw new IllegalArgumentException("Libraries groups cannot be null!"); | |
| } | |
| this.baseLibs = baseLibs; | |
| this.cpuEnhancedLibs = cpuEnhancedLibs; | |
| } | |
| /** | |
| * Instantiates a DLL Loader wrapper setting its logging, retry criteria, | |
| * and setting up its loading listeners. | |
| * | |
| * @param enableLogging enables the API level logger (default: false). | |
| * @param enableRetryCriterion enables retrying with clean extraction (default: false). | |
| * when loading failure for {@link LoadingCriterion#INCREMENTAL_LOADING} | |
| * routine. | |
| * @throws IllegalArgumentException if the caller stack has passed an undefined library information | |
| * reference. | |
| */ | |
| public NativeDllLoader(LibraryInfo info, boolean enableLogging, boolean enableRetryCriterion) { | |
| if (info == null) { | |
| throw new IllegalArgumentException("Cannot proceed with no library information!"); | |
| } | |
| loader = new ConcurrentNativeBinaryLoader(List.of(), info); | |
| loader.setLoggingEnabled(enableLogging); | |
| loader.setRetryWithCleanExtraction(enableRetryCriterion); | |
| loader.setNativeBinaryLoadingListener(this); | |
| loader.setLibraryLocalizingListener(this); | |
| } | |
| /** | |
| * Loads the base defined libraries providing an anti-failure routine | |
| * for loading from archive commands. This routine is thread-safe with other object routines. | |
| * | |
| * <p> | |
| * Possible execution stack: | |
| * Legend: | |
| * <code> | |
| * ">>" represents the initial state of the automata | |
| * "*" represents the terminal state of the automata; after | |
| * which the stack is owned by another machine. | |
| * "**" represents an imminent failure signal. | |
| * "->" represents a machine transitional delta. | |
| * </code> | |
| * <ul> | |
| * <li> Case 1: | |
| * <code> >> loadBaseLibraries(LoadingCriterion.INCREMENTAL_LOADING) -> | |
| * if (failure-cause == UnSupportedSystemError) -> exit() -> **. | |
| * </code> | |
| * </li> | |
| * <li> Case 2: | |
| * <code> >> loadBaseLibraries(LoadingCriterion.INCREMENTAL_LOADING) -> | |
| * if (failure-cause == LoadingRetryExhaustionException) -> onLoadingFailure() | |
| * -> loadBaseLibraries(LoadingCriterion.SYSTEM_LOAD) -> | |
| * if (failure-cause == UnsatisfiedLinkError) -> exit() -> **. | |
| * </code> | |
| * </li> | |
| * </ul> | |
| * </p> | |
| * | |
| * @param criterion the loading criterion, it's recommended to start with | |
| * {@link LoadingCriterion#INCREMENTAL_LOADING}; moreover | |
| * start with the {@link NativeDllLoader#loadCpuEnhancedLibs(LoadingCriterion)} (not null). | |
| * @throws Exception if I/O event or thread signal interrupt occurs. | |
| */ | |
| public synchronized void loadBaseLibraries(LoadingCriterion criterion) throws Exception { | |
| if (criterion == null) { | |
| throw new IllegalArgumentException("Cannot proceed with null loading criterion!"); | |
| } | |
| try { | |
| loader.registerNativeLibraries(baseLibs) | |
| .initPlatformLibrary() | |
| .loadLibrary(criterion); | |
| } catch (UnSupportedSystemError e) { | |
| signalImminentFailure( | |
| new CallingStackMetaData(Thread.currentThread().getStackTrace()[1], criterion, e)); | |
| } catch (LoadingRetryExhaustionException e) { | |
| // re-route retry failure to the same anti-failure routine | |
| this.onLoadingFailure(loader, | |
| new CallingStackMetaData(Thread.currentThread().getStackTrace()[1], criterion, e)); | |
| } | |
| } | |
| /** | |
| * Loads the registered CPU-enhanced libraries. Providing an anti-failure routine | |
| * for loading from archive commands. This is thread-safe with other routines. | |
| * | |
| * <p> | |
| * Possible execution stack: | |
| * <ul> | |
| * <li> Case 1 (Notice UnSupportedSystemError is thrown from the initPlatformLibrary | |
| * during which system selection is performed): | |
| * <code> >> exec: loadCpuEnhancedLibs(LoadingCriterion.INCREMENTAL_LOADING) -> | |
| * if (failure-cause == UnSupportedSystemError) -> onLoadingFailure -> | |
| * exec: loadBaseLibraries(LoadingCriterion.INCREMENTAL_LOADING) -> *. | |
| * </code> | |
| * </li> | |
| * <li> Case 2: | |
| * <code> >> exec: loadCpuEnhancedLibs(LoadingCriterion.INCREMENTAL_LOADING) -> | |
| * if (failure-cause == LoadingRetryExhaustionException) -> loadCpuEnhancedLibs(LoadingCriterion.SYSTEM_LOAD) | |
| * if (failure-cause == UnsatisfiedLinkError) -> onLoadingFailure -> exec: loadBaseLibraries(LoadingCriterion.INCREMENTAL_LOADING) | |
| * -> *. | |
| * </code> | |
| * </li> | |
| * <li> Case 3: | |
| * <code> | |
| * >> ...Some states... -> Any other failure cause -> exit() -> *. | |
| * </code> | |
| * </li> | |
| * </ul> | |
| * </p> | |
| * | |
| * @param criterion the type of loading; it's recommended to start with {@link LoadingCriterion#INCREMENTAL_LOADING}. | |
| * @throws Exception if I/O event or thread signal interrupt occurs. | |
| */ | |
| public synchronized void loadCpuEnhancedLibs(LoadingCriterion criterion) throws Exception { | |
| if (criterion == null) { | |
| throw new IllegalArgumentException("Cannot proceed with null loading criterion!"); | |
| } | |
| try { | |
| loader.registerNativeLibraries(cpuEnhancedLibs) | |
| .initPlatformLibrary() | |
| .loadLibrary(criterion); | |
| } catch (UnSupportedSystemError e) { | |
| // re-route system not found and retry failure to the same anti-failure routine | |
| this.onLoadingFailure(loader, | |
| new CallingStackMetaData(Thread.currentThread().getStackTrace()[1], criterion, e)); | |
| } catch (LoadingRetryExhaustionException e) { | |
| // retry with SYSTEM_LOAD | |
| // notice that LoadingRetryExhaustionException will never | |
| // happen with LoadingCriterion.SYSTEM_LOAD | |
| // the LoadingRetryExhaustionException is thrown as a result | |
| // of greater than 2 times throwing "UnSatisfiedLinkError" on the | |
| // INCREMENTAL Loading Stack (i.e., extracting stack). | |
| loadCpuEnhancedLibs(LoadingCriterion.SYSTEM_LOAD); | |
| } | |
| } | |
| @Override | |
| public void onLoadingSuccess(NativeBinaryLoader nativeBinaryLoader, CallingStackMetaData callingStackMetaData) { | |
| // initialize Jolt-Jni and physics update system | |
| // handling lifecycle to the internal Jolt-Physics Native | |
| // copied from Jolt-Jni Example | |
| String configuration = Jolt.getConfigurationString(); | |
| /* | |
| * Depending which native library was loaded, the configuration string | |
| * should be one of the following: | |
| * | |
| * On LINUX_X86_64 platforms, either | |
| * Single precision x86 64-bit with instructions: SSE2 SSE4.1 SSE4.2 AVX AVX2 F16C LZCNT TZCNT FMADD (Debug Renderer) (16-bit ObjectLayer) (Assertions) (ObjectStream) (Debug) (C++ RTTI) (C++ Exceptions) | |
| * or | |
| * Single precision x86 64-bit with instructions: SSE2 (Debug Renderer) (16-bit ObjectLayer) (Assertions) (ObjectStream) (Debug) (C++ RTTI) (C++ Exceptions) | |
| * | |
| * On WIN_X86_64 platforms, either | |
| * Single precision x86 64-bit with instructions: SSE2 SSE4.1 SSE4.2 AVX AVX2 F16C LZCNT TZCNT (FP Exceptions) (Debug Renderer) (16-bit ObjectLayer) (Assertions) (ObjectStream) (Debug) (C++ RTTI) (C++ Exceptions) | |
| * or | |
| * Single precision x86 64-bit with instructions: SSE2 (FP Exceptions) (Debug Renderer) (16-bit ObjectLayer) (Assertions) (ObjectStream) (Debug) (C++ RTTI) (C++ Exceptions) | |
| */ | |
| System.out.println(configuration); | |
| } | |
| @Override | |
| public synchronized void onLoadingFailure(NativeBinaryLoader nativeBinaryLoader, CallingStackMetaData callingStackMetaData) { | |
| // validate input! | |
| if (callingStackMetaData == null || callingStackMetaData.getCallingStack() == null || | |
| callingStackMetaData.getErrorCause() == null || callingStackMetaData.getLoadingCriterion() == null) { | |
| throw new IllegalArgumentException("Failure stack metadata structure cannot be null!"); | |
| } | |
| final String callingMethod = callingStackMetaData.getCallingStack().getMethodName(); | |
| // log calling stack! | |
| SnapLoaderLogger.log(Level.INFO, callingStackMetaData.getCallingStack().getClassName(), | |
| callingStackMetaData.getCallingStack().getMethodName(), | |
| "Failure Stack", callingStackMetaData.getErrorCause()); | |
| try { | |
| if (callingStackMetaData.getErrorCause() instanceof LoadingRetryExhaustionException) { | |
| if (callingMethod.contains("loadCpuEnhancedLibs")) { | |
| // try cpu enhanced libs from system directory | |
| loadCpuEnhancedLibs(LoadingCriterion.SYSTEM_LOAD); | |
| } else if (callingMethod.contains("loadBaseLibraries")) { | |
| // try loading base libraries from system directories if loading is exhausted! | |
| loadBaseLibraries(LoadingCriterion.SYSTEM_LOAD); | |
| } | |
| } else if (callingStackMetaData.getErrorCause() instanceof UnsatisfiedLinkError) { | |
| if (callingMethod.contains("loadCpuEnhancedLibs")) { | |
| // no retry criteria? | |
| // or loading from system directory? | |
| // Exit the loadCpuEnhancedLibs stack frames! | |
| loadBaseLibraries(LoadingCriterion.INCREMENTAL_LOADING); | |
| } else if (callingMethod.contains("loadBaseLibraries")) { | |
| signalImminentFailure(callingStackMetaData); | |
| } | |
| } else if (callingStackMetaData.getErrorCause() instanceof FilesystemResourceInitializationException) { | |
| if (callingMethod.contains("onFileLocalizationFailure")) { | |
| loadCpuEnhancedLibs(LoadingCriterion.SYSTEM_LOAD); | |
| } | |
| } | |
| } catch (Exception e) { | |
| signalImminentFailure(callingStackMetaData); | |
| } | |
| } |
NativeVariant.Cpu.hasExtensions(...):Introduced in 1.1.0-stable.
Lines 43 to 90 in a13f2ee
| /** | |
| * Tests selection between native libraries based on CPU features. | |
| * | |
| * @author Stephen Gold sgold@sonic.net | |
| */ | |
| public final class TestCpuFeatures { | |
| public static void main(String[] argv) { | |
| // Test for each of the relevant CPU features: | |
| System.out.println("avx = " + NativeVariant.Cpu.hasExtensions("avx")); | |
| System.out.println("avx2 = " + NativeVariant.Cpu.hasExtensions("avx2")); | |
| System.out.println("bmi1 = " + NativeVariant.Cpu.hasExtensions("bmi1")); | |
| System.out.println("f16c = " + NativeVariant.Cpu.hasExtensions("f16c")); | |
| System.out.println("fma = " + NativeVariant.Cpu.hasExtensions("fma")); | |
| System.out.println("sse4_1 = " + NativeVariant.Cpu.hasExtensions("sse4_1")); | |
| System.out.println("sse4_2 = " + NativeVariant.Cpu.hasExtensions("sse4_2")); | |
| // Define a custom predicate for Linux with all 7 CPU features: | |
| PlatformPredicate linuxWithFma = new PlatformPredicate( | |
| PlatformPredicate.LINUX_X86_64, | |
| "avx", "avx2", "bmi1", "f16c", "fma", "sse4_1", "sse4_2"); | |
| System.out.println("linuxWithFma = " + linuxWithFma.evaluatePredicate()); | |
| // Define a custom predicate for Windows with 4 CPU features: | |
| PlatformPredicate windowsWithAvx2 = new PlatformPredicate( | |
| PlatformPredicate.WIN_X86_64, | |
| "avx", "avx2", "sse4_1", "sse4_2"); | |
| System.out.println("windowsWithAvx2 = " + windowsWithAvx2.evaluatePredicate()); | |
| System.out.flush(); | |
| LibraryInfo info = new LibraryInfo( | |
| new DirectoryPath("linux/x86-64/com/github/stephengold"), | |
| "joltjni", DirectoryPath.USER_DIR); | |
| NativeBinaryLoader loader = new NativeBinaryLoader(info); | |
| NativeDynamicLibrary[] libraries = { | |
| new NativeDynamicLibrary("linux/x86-64-fma/com/github/stephengold", linuxWithFma), // must precede vanilla LINUX_X86_64 | |
| new NativeDynamicLibrary("linux/x86-64/com/github/stephengold", PlatformPredicate.LINUX_X86_64), | |
| new NativeDynamicLibrary("windows/x86-64-avx2/com/github/stephengold", windowsWithAvx2), // must precede vanilla WIN_X86_64 | |
| new NativeDynamicLibrary("windows/x86-64/com/github/stephengold", PlatformPredicate.WIN_X86_64) | |
| }; | |
| loader.registerNativeLibraries(libraries).initPlatformLibrary(); | |
| loader.setLoggingEnabled(true); | |
| loader.setRetryWithCleanExtraction(true); | |
| try { | |
| loader.loadLibrary(LoadingCriterion.CLEAN_EXTRACTION); | |
| } catch (Exception e) { | |
| throw new IllegalStateException("Failed to load the joltjni library!"); | |
| } |
NativeDynamicLibrary (NEW).NativeVariant providing system properties.Those projects had contributed implicitly and/or explicitly and must be recognized:
I owe these people a cup of coffee for their gracious contributions, when we eventually meet:
Electrostat-Lab/jSnapLoader is a public repo on GitHub by Electrostat-Lab. A high-performance cross-platform native Library loader API for JVM Applications.
It declares the BSD-3-Clause license on GitHub.
Its maker tagged it for macOS, Windows and Linux, or as Docker or cross-platform. That is declared by the maker; Take My Repo has not tested it.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-10-18. GitHub counts 4 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Reverse engineer anything with agents, from app behavior down to native binaries.
Flutter makes it easy and fast to build beautiful apps for mobile and beyond
f.k.a. Awesome ChatGPT Prompts. Share, discover, and collect prompts from the community. Free and open source — self-host for your organization with complete privacy.
Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
A high-performance infrastructure framework for distributed systems simulation based on the IEEE-1516 HLA Spec. and NASA DSES.
An Android API housing useful re-usbable Human-computer Interfaces (HCI) in the form of in-game android views with an integration API for jMonkeyEngine.

Dig deeper into the AVR-WORLD using the 8-bit mcu avr devices on a special shell environment.
An entity component system (ECS) framework featuring strong articulations among components from different systems through controller interfaces. 'Everything is a Component' & 'ECS Modules' is what makes it special!

A classic finite state automaton framework for JVM Applications (Android and jMonkeyEngine Applications).
A direct dynamic memory allocation API for jMonkeyEngine lwjgl-2 and android games
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/Electrostat-Lab/jSnapLoaderTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.