跨平台的 Switch模拟器-Eden

Eden 是 Nintendo Switch 模拟器 Yuzu 的衍生分支项目，由前 Citron 模拟器开发者 Camille LaVey 及其团队主导开发，旨在成为 Yuzu 的继任者，提升性能与兼容性 。采用 C++ 编写，遵循 GPLv3 开源协议，代码托管于自有 Git 服务器。目前已上线Google play。

核心特性

    跨平台支持：兼容 Windows、Linux、Android 及 Steam Deck，注重可移植性 。
    性能优化：
        引入动态调整 CPU/GPU 频率、Vulkan 渲染优化、LRU 缓存等技术，显著提升游戏流畅度和画质 。
        支持 4K 分辨率渲染、高帧率运行（如 120 插值 FPS），并新增 插帧（Frame Interpolation）与跳帧（Frame Skipping）功能，优化中低端设备体验 。
    兼容性：可运行《塞尔达传说：旷野之息》《超级马里奥奥德赛》《异度神剑X》等主流游戏，在骁龙 8 Elite 等旗舰芯片设备上能发挥硬件全部潜力 。

开发进展与版本发布

    首个版本：于 2025 年 5 月 11 日发布预测试版（v0.0.1-pre-Alpha），提供中文版及基础功能 。
    后续更新：
        v0.0.2-pre-alpha 新增 本地多人游戏支持 。
        持续优化兼容性，如《塞尔达传说》在默认设置下可达 28-30 FPS（未录制时）。
    当前状态：截至 2025 年 8 月，已发布 Beta 版，界面更简洁，无广告或强制收费 。

 安装与使用

    依赖文件：需搭配 Switch 固件（Firmware）、密钥（Prod.ke ys/Title.ke ys） 及游戏 ROM 使用，用户需自行合法获取 。
    安装步骤：
        从官网或社区渠道下载模拟器 。
        导入固件、密钥及游戏文件。
        设置语言、渲染器（推荐 Vulkan）及图形选项 。
    高级功能：支持模组管理、自定义分辨率、外接手柄及运动控制 。

与其他模拟器的对比

    优于 Yuzu/Sudachi：作为 Yuzu 的优化分支，Eden 在性能（尤其 Android 端）和兼容性上表现更佳，且持续更新（Yuzu 已停更）。
    Citron 的替代品：因 Citron 开发停滞，Eden 成为其继承者，底层代码更先进，界面更友好。

源代码：https://git.eden-emu.dev/eden-emu/eden
------------------------------------------------------------

 

Eden is a free and opensource (FOSS) Switch 1 emulator, derived from Yuzu and Sudachi - started by developer Camille LaVey. It's written in C++ with portability in mind, with builds for Windows, Linux, macOS, Android, FreeBSD and more.

Compatibility | Development | Building | Download | Support | License

Compatibility

The emulator is capable of running most commercial games at full speed, provided you meet the necessary hardware requirements.

A list of supported games will be available in future. Please be patient.

Check out our website for the latest news on exciting features, monthly progress reports, and more!

Development

Most of the development happens on our Git server. It is also where our central repository is hosted. For development discussions, please join us on Discord or Stoat. You can also follow us on X (Twitter) for updates and announcements.

If you would like to contribute, we are open to new developers and pull requests. Please ensure that your work is of a high standard and properly documented. You can also contact any of the developers on Discord or Stoat to learn more about the current state of the emulator.

See the sign-up instructions for information on registration.

from  https://git.eden-emu.dev/eden-emu/eden

-----------------------------------------------------------

 

Dependencies

To build Eden, you MUST have a C++ compiler.

• On Linux, this is usually GCC 11+ or Clang v14+
  • GCC 12 also requires Clang 14+
• On Windows, we support:
  • MSVC (default)
    • It's STRONGLY RECOMMENDED to use the Community option and Visual Studio 2022
    • You need to install: Desktop development with C++
  • clang-cl
    • You need to install: C++ Clang tools for Windows
  • MSYS2
• On macOS, this is Apple Clang
  • This can be installed with xcode-select --install

The following additional tools are also required:

• CMake 3.22+ - already included with the Android SDK
• Git for version control
  • Windows installer
• Python3 3.10+ - necessary to download external repositories
• On Windows, you must install the Vulkan SDK as well
  • A convenience script to install the latest SDK is provided in:
    • tools/windows/install-vulkan-sdk.ps1 (for PowerShell 5+)
    • tools/windows/install-vulkan-sdk.sh (for Git Bash, etc)

If you are on desktop and plan to use the Qt frontend, you must install Qt 6, and optionally Qt Creator (the RECOMMENDED IDE for building)

• On Linux, *BSD and macOS, this can be done by the package manager

  • If you wish to use Qt Creator, append qtcreator or qt-creator to the commands seen below.

• MSVC/clang-cl users on Windows must install through the official Qt installer

• Linux and macOS users may choose to use the installer as well.

• MSYS2 can also install Qt 6 via the package manager

• For help setting up Qt Creator, run ./install.sh -h qtcreator

If you are on Windows and building with MSVC or clang-cl, you may go back home and continue.

Externals

The following are handled by Eden's externals:

• FFmpeg (should use -DYUZU_USE_EXTERNAL_FFMPEG=ON)
• SDL2 2.0.18+ (should use -DYUZU_USE_EXTERNAL_SDL2=ON OR -DYUZU_USE_BUNDLED_SDL2=ON to reduce compile time)

All other dependencies will be downloaded and built by CPM if YUZU_USE_CPM is on, but will always use system dependencies if available (UNIX-like only):

• Boost 1.57.0+
• Catch2 3.0.1 if YUZU_TESTS or DYNARMIC_TESTS are on
• fmt 8.0.1+
• lz4
• nlohmann_json 3.8+
• OpenSSL 1.1.1+
• ZLIB 1.2+
• zstd 1.5+
• enet 1.3+
• Opus 1.3+
• MbedTLS 3+

Vulkan 1.3.274+ is also needed:

• VulkanUtilityLibraries
• VulkanHeaders
• SPIRV-Tools
• SPIRV-Headers

Certain other dependencies will be fetched by CPM regardless. System packages can be used for these libraries, but many are either not packaged by most distributions OR have issues when used by the system:

• SimpleIni
• DiscordRPC
• cubeb
• libusb
• VulkanMemoryAllocator
• sirit
• httplib - if ENABLE_UPDATE_CHECKER or ENABLE_WEB_SERVICE are on
  • This package is known to be broken on the AUR.
• cpp-jwt 1.4+ - if ENABLE_WEB_SERVICE is on
• unordered-dense
• mcl - subject to removal

On amd64:

• xbyak - 7.22 or earlier is recommended

On aarch64 OR if DYNARMIC_TESTS is on:

• oaknut 2.0.1+

On riscv64:

• biscuit 0.9.1+

from  https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/Deps.md

-----------------------------------------------------------

Building Eden

Warning

This guide is intended for developers ONLY. If you are not a developer or packager, you are unlikely to receive support.

This is a full-fledged guide to build Eden on all supported platforms.

Dependencies

First, you must install some dependencies.

Clone

Next, you will want to clone Eden via the terminal:

git clone https://git.eden-emu.dev/eden-emu/eden.git
cd eden

Or use Qt Creator (Create Project -> Import Project -> Git Clone).

Android

Android has a completely different build process than other platforms. See its dedicated page.

Initial Configuration

If the configure phase fails, see the Troubleshooting section below. Usually, as long as you followed the dependencies guide, the defaults should successfully configure and build.

Option A: Qt Creator

This is the recommended GUI method for Linux, macOS, and Windows.

Click to Open

Option B: Command Line

Click to Open

Warning

For all systems:

• CMake MUST be in your PATH (and also ninja, if you are using it as <GENERATOR>)
• You MUST be in the cloned Eden directory

On Windows:

• It's recommended to install Ninja
• You must load Visual C++ development environment, this can be done by running our convenience script:
  • tools/windows/load-msvc-env.ps1 (for PowerShell 5+)
  • tools/windows/load-msvc-env.sh (for MSYS2, Git Bash, etc)

Available <GENERATOR>:

• MSYS2: MSYS Makefiles
• MSVC: Ninja (preferred) or Visual Studio 17 2022
• macOS: Ninja (preferred) or Xcode
• Others: Ninja (preferred) or UNIX Makefiles

Available <BUILD_TYPE>:

• Release (default)
• RelWithDebInfo (debug symbols--compiled executable will be large)
• Debug (if you are using a debugger and annoyed with stuff getting optimized out)

Caveat for Debug Builds:

• If you're building with CCache, you will need to add the environment variable CL with the /FS flag (Reference)

Also see the Options page for additional CMake options.

cmake -S . -B build -G "<GENERATOR>" -DCMAKE_BUILD_TYPE=<BUILD_TYPE> -DYUZU_TESTS=OFF

If you are on Windows and prefer to use Clang:

cmake -S . -B build -G "<GENERATOR>" -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl

Alternatively, if you wish to add translations, go to the Eden project on Transifex and review the translations README.

Building

See the General Build Guide

For information on provided development tooling, see the Tools directory

from  https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/Build.md

 

编译libresprite

 

Installation

Table of contents

• Platforms
• Get the source code
• Dependencies
  • Linux dependencies
  • Windows dependencies
  • MacOS dependencies
• Compiling
  • Linux details
  • Windows details
  • MacOS details
  • Android details
• Installing

Platforms

You can download installers from the website. If you want to compile LibreSprite from source, continue reading.

You should be able to compile LibreSprite on the following platforms:

• Windows 10 + VS2015 Community Edition + Windows 10 SDK
• Mac OS X 11.0 Big Sur + Xcode 7.3 + OS X 11.0 SDK
• Linux + GCC 8.5 or higher with C++14 support

To compile LibreSprite you will need:

• CMake (3.4 or greater)
• Ninja
• Msys2 (Windows only)

Get the source code

Clone the repository and its submodules using the following command:

git clone --recursive https://github.com/LibreSprite/LibreSprite

(You can use Git for Windows to clone the repository on Windows.)

To update an existing clone, use the following commands:

cd LibreSprite
git pull
git submodule update --init --recursive

Dependencies

You'll need the following dependencies to compile LibreSprite:

Linux dependencies

Debian/Ubuntu:

sudo apt-get install cmake g++ libcurl4-gnutls-dev libfreetype6-dev libgif-dev libgtest-dev libjpeg-dev libpixman-1-dev libpng-dev libsdl2-dev libsdl2-image-dev libtinyxml2-dev libnode-dev ninja-build zlib1g-dev libarchive-dev

Fedora:

sudo dnf install g++ cmake libcurl-devel freetype-devel giflib-devel gtest-devel libjpeg-devel pixman-devel libpng-devel SDL2-devel SDL2_image-devel tinyxml2-devel zlib-devel ninja-build nodejs-devel libarchive-devel

Windows dependencies

To install the required dependencies with msys2, run the following in mingw32:

pacman -S base-devel mingw-w64-i686-gcc mingw-w64-i686-cmake mingw-w64-i686-make mingw-w64-i686-curl mingw-w64-i686-freetype mingw-w64-i686-giflib mingw-w64-i686-libjpeg-turbo mingw-w64-i686-libpng mingw-w64-i686-libwebp mingw-w64-i686-pixman mingw-w64-i686-SDL2 mingw-w64-i686-SDL2_image mingw-w64-i686-tinyxml2 mingw-w64-i686-v8 mingw-w64-i686-zlib mingw-w64-i686-libarchive

MacOS dependencies

On MacOS you will need Mac OS X 11.0 SDK and the corresponding Xcode. In a terminal, install the dependencies using brew:

brew install gnutls freetype jpeg webp pixman sdl2 sdl2_image tinyxml2 libarchive v8 ninja zlib xmlto dylibbundler cmake

Compiling

First, create the build directory with the following commands:

cd LibreSprite
mkdir build
cd build

Then following the platform-specific instructions for compiling below.

The build directory will contain the results of the compilation process. If you want to build a fresh copy of LibreSprite, remove the build directory and recompile.

Linux details

To compile LibreSprite, run the following commands:

cmake -G Ninja ..
ninja libresprite

Windows details

Run the following in mingw32.exe:

cmake -G Ninja ..

MacOS details

To compile LibreSprite, run the following commands:

    cmake \
      -DCMAKE_OSX_SYSROOT=/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk \
      -G Ninja \
      ..
    ninja libresprite

Android details

Before you can make an Android build, you must make a native build for your OS, so follow the appropriate instructions above. Once that is done, download https://github.com/LibreSprite/ls-android-deps as android/ in the LibreSprite directory. Now you can open the android subdirectory in Android Studio and build LibreSprite for Android.

Installing

Once you've finished compiling, you can install LibreSprite by running the following command from the build directory:

ninja install

from https://github.com/LibreSprite/LibreSprite/blob/master/INSTALL.md 

-----------------------------------------------------

 https://github.com/LibreSprite/LibreSprite/

vkQuake

vkQuake is a port of id Software's Quake using Vulkan instead of OpenGL for rendering. It is based on the popular QuakeSpasm and QuakeSpasm-Spiked ports and runs all mods compatible with QuakeSpasm like Arcane Dimensions.

Improvements over QuakeSpasm include:

• Much better performance with multithreaded rendering and loading
• The game can run at higher frame rates than 72Hz without breaking physics
• A software Quake like underwater effect
• Support for remastered models if using data from the 2021 rerelease
• Dynamic shadows (requires a GPU with ray tracing support)
• Better color precision reducing banding in dark areas
• Native support for anti aliasing and anisotropic filtering
• 8-bit color emulation
• Scaling for pixelated look
• Mods menu for easy mod loading
• More modern protocol to avoid certain movement issues (from QSS)
• Support for custom mod HUDs (from QSS)
• Support for scriptable particles (from QSS)

Installation

Windows

It is recommended to use the installer on Windows. This sets up start menu entries for the original and remastered Quake versions. Save data and config files will be written to the user folder (%APPDATA\vkQuake) instead of the Quake data folder.

Otherwise copy all files inside the vkquake-<version>_win64 or vkquake-<version>_win32 folder in the zip to the Quake base directory. Overwrite any existing files. Afterward to run the game just execute vkQuake.exe.

Linux

Copy all files inside the vkquake-<version>-linux64 folder in the tar archive to the Quake base directory. Overwrite any existing files. Run vkquake.AppImage.

Note
Make sure all data files are lowercase, e.g. "id1", not "ID1" and "pak0.pak", not "PAK0.PAK". Some distributions of the game have upper case file names, e.g. from GOG.com.

OpenBSD

OpenBSD includes vkQuake in the standard package repositories since version 6.6.

If you're running OpenBSD 6.6 or greater you can install the package with:

$ pkg_add vkquake

Quake '2021 re-release'

vkQuake has initial support for playing the 2021 re-release content. Follow installation instructions as above but copy the files into the rerelease folder.

Vulkan

vkQuake shows basic usage of the API. For example it demonstrates render passes & sub passes, pipeline barriers & synchronization, compute shaders, push & specialization constants, CPU/GPU parallelism and memory pooling.

Building

Note
You will need at least Vulkan SDK version 1.2.162 or newer. When building for Linux this is not always the case for the SDK provided by the distribution. Install the latest LunarG SDK if necessary.

Windows

Clone the vkQuake repo from https://github.com/Novum/vkQuake.git

Prerequisites:

• Git for Windows
• A Vulkan-capable GPU with the appropriate drivers installed
• Install the latest Vulkan SDK. Log out and back in after installation to make sure environment variables are set.

Visual Studio

• Install Visual Studio Community with Visual C++ component.

Open the Visual Studio solution, Windows\VisualStudio\vkquake.sln, select the desired configuration and platform, then build the solution.

Linux

Make sure that both your GPU and your GPU driver support Vulkan.

To compile vkQuake, first install the build dependencies:

Ubuntu:

apt-get install git meson gcc glslang-tools spirv-tools libsdl2-dev libvulkan-dev libvorbis-dev libmad0-dev libx11-xcb-dev

Arch Linux:

pacman -S git meson flac glibc libgl libmad libvorbis libx11 sdl2 vulkan-headers glslang spirv-tools

Then clone the vkQuake repo:

git clone https://github.com/Novum/vkQuake

Now go to the Quake directory and compile the executable:

cd vkQuake
meson build && ninja -C build

Note
The Meson version needs to be 0.47.0 or newer. For older distributions you can use make:

cd vkQuake/Quake
make -j

Meson is the preferred way to build vkQuake because it automatically checks for out of date file depenencies, is faster and has better error reporting for missing dependencies.

Note
vkQuake 0.97 and later requires at least SDL2 2.0.6 with enabled Vulkan support. The precompiled versions in some of the distribution repositories (e.g. Ubuntu) do not currently ship with Vulkan support. You will therefore need to compile it from source. Make sure you have libvulkan-dev installed before running configure.

MacOS

To compile vkQuake, first install the build dependencies with Homebrew:

brew install molten-vk vulkan-headers glslang spirv-tools sdl2 libvorbis flac opus opusfile flac mad meson pkgconfig

Then clone the vkQuake repo:

git clone https://github.com/Novum/vkQuake.git

Now go to the Quake directory and compile the executable:

cd vkQuake
meson build && ninja -C build

Note
The Meson version needs to be 0.47.0 or newer.

MinGW

Setup your MinGW-w64 environment, e.g. using w64devkit or MSYS2.

Build 32 bit (x86) vkQuake:

cd vkQuake/Quake
make -f Makefile.w32

Build 64 bit (x64) vkQuake:

cd vkQuake/Quake
make -f Makefile.w64

If you are on Linux and want to cross-compile for Windows, see the build_cross_win??.sh scripts.

Optional - Music / Soundtrack

Note
This section only applies to older releases. For the 2021 re-release music will work out of the box.

The original Quake had a great soundtrack by Nine Inch Nails. Unfortunately, the Steam version does not come with the soundtrack files. The GOG-provided files need to be converted before they are ready for use. In general, you'll just need to move a "music" folder to the correct location within your vkQuake installation (.e.g /usr/share/quake/id1/music). Most Quake engines play nicest with soundtracks placed in the id1/music subfolder vs. sound\cdtracks

QuakeSpasm, the engine vkQuake is derived from, supports OGG, MP3, FLAC, and WAV audio formats. The Linux version of QuakeSpasm/VkQuake requires external libraries: libogg or libvorbis for OGG support, libmad or libmpg123 for MP3, and libflac for FLAC. If you already have a setup that works for the engine you're currently using, then you don't necessarily have to change it.

Generally, the below setup works for multiple engines, including Quakespasm/vkQuake:

• The music files are loose files, NOT inside a pak or pk3 archive.
• The files are placed inside a "music" subfolder of the "id1" folder. For missionpack or mod soundtracks, the files are placed in a "music" subfolder of the appropriate game folder. So the original Quake soundtrack files go inside "id1\music", Mission Pack 1 soundtrack files go inside "hipnotic\music", and Mission Pack 2 soundtrack files go inside "rogue\music".
• The files are named in the pattern "tracknn", where "nn" is the CD track number that the file was ripped from. Since the soundtrack starts at the second CD track, MP3 soundtrack files are named "track02.mp3", "track03.mp3", etc. OGG soundtrack files are named "track02.ogg", "track03.ogg", etc. FLAC soundtrack files are named "track02.flac", "track03.flac", etc. WAV soundtrack files are named "track02.wav", "track03.wav", etc.

See more: Quake Soundtrack Solutions (Steam Community)

from https://github.com/Novum/vkQuake

cog by Igalia

 WPE launcher and webapp container.

Cog is a small single “window” launcher for the WebKit WPE port. It is small, provides no user interface, and is suitable to be used as a Web application container. The “window” may be fullscreen depending on the WPE backend being used.

This project provides the following components:

• libcogcore is a library with ready-to-use components typically needed for implementing applications which use the WPE WebKit API.

• cog is the launcher itself, implemented using the libcogcore library.

• cogctl is a tool which can be used to control a cog instance using the D-Bus session bus.

It is possible to disable building the cog and cogctl programs by passing -Dprograms=false to Meson.

Dependencies

Stable releases have the following dependencies:

• WPE WebKit 2.28.x
• WPEBackend-fdo 1.8.x (optional, recommended)

Note that building from the master branch will often require development releases of WPE WebKit, libwpe, and WPEBackend-fdo; while older Cog releases may have different version requirements.

Using Cog

Compiling Cog follows the usual procedure for projects which use Meson: meson setup build && ninja -C build should get you started, if your system has the needed dependencies installed.

Documentation is available at igalia.github.io/cog but it is currently incomplete. Contributions in this regard are very welcome.

Bug tracking: If you have found a bug, take a look at out issue tracker. Please see the “reporting bugs” section in the CONTRIBUTING.md file for guidelines on how to provide a good bug report.

from https://github.com/Igalia/cog

 

LibreSprite

 Animated sprite editor & pixel art tool.

Introduction

LibreSprite is a free and open source program for creating and animating your sprites.

• Real-time animation previews.
• Onion skinning.
• Multiple sprites can be edited at once.
• Ready to use palettes, or make your own.
• Sprites are composed of both layers & frames.
• Tiled drawing mode, useful to draw patterns and textures.
• Pixel precise tools like filled contour, polygon, shading mode, etc.
• Several file types supported for your sprites and animations.

Download

Grab an AppImage for Linux, or get the Windows Portable.

History

LibreSprite originated as a fork of Aseprite, developed by David Capello. Aseprite used to be distributed under the GNU General Public License version 2, but was moved to a proprietary license on August 26th, 2016.

This fork was made on the last commit covered by the GPL version 2 license, and is now developed independently of Aseprite.

Compiling

Don't worry, it isn't as hard as you might think! Just follow the instructions here.

Theming

Don't like the default look of Libresprite? Don't panic, you can download from the Libresprite resources repo.

from https://github.com/LibreSprite/LibreSprite

------------------------------------

Installation

Table of contents

• Platforms
• Get the source code
• Dependencies
  • Linux dependencies
  • Windows dependencies
  • MacOS dependencies
• Compiling
  • Linux details
  • Windows details
  • MacOS details
• Installing

Platforms

You can download installers from the website. If you want to compile LibreSprite from source, continue reading.

You should be able to compile LibreSprite on the following platforms:

• Windows 10 + VS2015 Community Edition + Windows 10 SDK
• Mac OS X 11.0 Big Sur + Xcode 7.3 + OS X 11.0 SDK
• Linux + GCC 8.5 or higher with C++14 support

To compile LibreSprite you will need:

• CMake (3.4 or greater)
• Ninja
• vcpkg (Windows and MacOS only)

Get the source code

Clone the repository and its submodules using the following command:

git clone --recursive https://github.com/LibreSprite/LibreSprite

(You can use Git for Windows to clone the repository on Windows.)

To update an existing clone, use the following commands:

cd LibreSprite
git pull
git submodule update --init --recursive

Backends

LibreSprite can be compiled with two different backends:

1. SDL2 backend (WIP)
2. Allegro backend (deprecated) (Windows and Linux only)

Dependencies

You'll need the following dependencies to compile LibreSprite:

Linux dependencies

Debian/Ubuntu:

sudo apt-get install cmake g++ libcurl4-gnutls-dev libfreetype6-dev libgif-dev libgtest-dev libjpeg-dev liblua5.4-dev libpixman-1-dev libpng-dev libsdl2-dev libsdl2-image-dev libtinyxml-dev libnode-dev ninja-build zlib1g-dev

Fedora:

sudo dnf install g++ cmake libcurl-devel freetype-devel giflib-devel gtest-devel libjpeg-devel lua-devel pixman-devel libpng-devel SDL2-devel SDL2_image-devel tinyxml-devel zlib-devel ninja-build nodejs-devel

Windows dependencies

To install the required dependencies with vcpkg, run:

vcpkg install curl freetype giflib gtest libjpeg-turbo lua libpng libwebp pixman sdl2 sdl2-image tinyxml v8 zlib --triplet x64-windows

Beware: --triplet x64-windows is only necessary for a 64 architecture build.

MacOS dependencies

On MacOS you will need Mac OS X 11.0 SDK and Xcode 7.3 (older versions might work).

Compiling

First, create the build directory with the following commands:

cd LibreSprite
mkdir build
cd build

Then following the platform-specific instructions for compiling below.

The build directory will contain the results of the compilation process. If you want to build a fresh copy of LibreSprite, remove the build directory and recompile.

Linux details

To compile LibreSprite, run the following commands:

cmake -G Ninja ..
ninja libresprite

To compile the legacy Allegro backend, run cmake with the flags -DUSE_SDL2_BACKEND=off -DUSE_ALLEG4_BACKEND=on.

The repository contains a patched version of the Allegro 4 library. If you want to use your installed version of Allegro, run cmake with the flag -DUSE_SHARED_ALLEGRO4=ON. However, this is not recommended due to issues with Allegro 4.4 (1) (2).

Windows details

If you're using a command prompt and aiming for a x64 build, be sure to use the x64 prompt or it won't find vcpkg libraries.

To compile LibreSprite, run the following commands:

cmake ^
  -DCMAKE_TOOLCHAIN_FILE=put_your_vcpkg_path_here\vcpkg\scripts\buildsystems\vcpkg.cmake ^
  -G Ninja ^
  ..

To compile the legacy Allegro backend, run cmake with the flags -DUSE_SDL2_BACKEND=off -DUSE_ALLEG4_BACKEND=on.

The repository contains a patched version of the Allegro 4 library. If you want to use your installed version of Allegro, run cmake with the flag -DUSE_SHARED_ALLEGRO4=on.

MacOS details

To compile LibreSprite, run the following commands:

cmake \
  -DCMAKE_OSX_ARCHITECTURES=x86_64 \
  -DCMAKE_OSX_DEPLOYMENT_TARGET=10.7 \
  -DCMAKE_OSX_SYSROOT=/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.0.sdk \
  -G Ninja \
  ..
ninja libresprite

Installing

Once you've finished compiling, you can install LibreSprite by running the following command from the build directory:

ninja install 

from https://github.com/LibreSprite/LibreSprite/blob/master/INSTALL.md 

 

 

Ninja

 a small build system with a focus on speed.

ninja-build.org/

Ninja is a small build system with a focus on speed. https://ninja-build.org/

See the manual or doc/manual.asciidoc included in the distribution for background and more details.

Binaries for Linux, Mac, and Windows are available at GitHub. Run ./ninja -h for Ninja help.

Installation is not necessary because the only required file is the resulting ninja binary. However, to enable features like Bash completion and Emacs and Vim editing modes, some files in misc/ must be copied to appropriate locations.

If you're interested in making changes to Ninja, read CONTRIBUTING.md first.

Building Ninja itself

You can either build Ninja via the custom generator script written in Python or via CMake. For more details see the wiki.

Python

./configure.py --bootstrap

This will generate the ninja binary and a build.ninja file you can now use to build Ninja with itself.

CMake

cmake -Bbuild-cmake
cmake --build build-cmake

The ninja binary will now be inside the build-cmake directory (you can choose any other name you like).

To run the unit tests:

./build-cmake/ninja_test 

from https://github.com/ninja-build/ninja 

 

nng

nanomsg-next-generation -- light-weight brokerless messaging.

nng.nanomsg.org

If you are looking for the legacy version of nanomsg, please see the nanomsg repository.

This project is a rewrite of the Scalability Protocols library known as libnanomsg, and adds significant new capabilities, while retaining compatibility with the original.

It may help to think of this as "nanomsg-next-generation".

NNG: Lightweight Messaging Library

NNG, like its predecessors nanomsg (and to some extent ZeroMQ), is a lightweight, broker-less library, offering a simple API to solve common recurring messaging problems, such as publish/subscribe, RPC-style request/reply, or service discovery. The API frees the programmer from worrying about details like connection management, retries, and other common considerations, so that they can focus on the application instead of the plumbing.

NNG is implemented in C, requiring only C99 and CMake to build. It can be built as a shared or a static library, and is readily embeddable. It is also designed to be easy to port to new platforms if your platform is not already supported.

License

NNG is licensed under a liberal, and commercial friendly, MIT license. The goal to the license is to minimize friction in adoption, use, and contribution.

Enhancements (Relative to nanomsg)

Here are areas where this project improves on "nanomsg":

Reliability	NNG is designed for production use from the beginning. Every error case is considered, and it is designed to avoid crashing except in cases of gross developer error. (Hopefully we don’t have any of these in our own code.)
Scalability	NNG scales out to engage multiple cores using a bespoke asynchronous I/O framework, using thread pools to spread load without exceeding typical system limits.
Maintainability	NNG’s architecture is designed to be modular and easily grasped by developers unfamiliar with the code base. The code is also well documented.
Extensibility	Because it avoids ties to file descriptors, and avoids confusing interlocking state machines, it is easier to add new protocols and transports to NNG. This was demonstrated by the addition of the TLS and ZeroTier transports.
Security	NNG provides TLS 1.2 and ZeroTier transports, offering support for robust and industry standard authentication and encryption. In addition, it is hardened to be resilient against malicious attackers, with special consideration given to use in a hostile Internet.
Usability	NNG eschews slavish adherence parts of the more complex and less well understood POSIX APIs, while adopting the semantics that are familiar and useful. New APIs are intuitive, and the optional support for separating protocol context and state from sockets makes creating concurrent applications vastly simpler than previously possible.

Compatibility

This project offers both wire compatibility and API compatibility, so most nanomsg users can begin using NNG right away.

Existing nanomsg and mangos applications can inter-operate with NNG applications automatically.

That said, there are some areas where legacy nanomsg still offers capabilities NNG lacks — specifically enhanced observability with statistics, and tunable prioritization of different destinations are missing, but will be added in a future release.

Additionally, some API capabilities that are useful for foreign language bindings are not implemented yet.

Some simple single threaded, synchronous applications may perform better under legacy nanomsg than under NNG. (We believe that these applications are the least commonly deployed, and least interesting from a performance perspective. NNG’s internal design is slightly less efficient in such scenarios, but it greatly benefits when concurrency or when multiple sockets or network peers are involved.)

Supported Platforms

NNG supports Linux, macOS, Windows (Vista or better), illumos, Solaris, FreeBSD, Android, and iOS. Most other POSIX platforms should work out of the box but have not been tested. Very old versions of otherwise supported platforms might not work.

Requirements

To build this project, you will need a C99 compatible compiler and CMake version 3.13 or newer.

We recommend using the Ninja build system (pass "-G Ninja" to CMake) when you can. (And not just because Ninja sounds like "NNG" — it’s also blindingly fast and has made our lives as developers measurably better.)

If you want to build with TLS support you will also need mbedTLS. See docs/BUILD_TLS.adoc for details.

Quick Start

With a Linux or UNIX environment:

  $ mkdir build
  $ cd build
  $ cmake -G Ninja ..
  $ ninja
  $ ninja test
  $ ninja install

API Documentation

The API documentation is provided in Asciidoc format in the docs/man subdirectory, and also online. The libnng(3) page is a good starting point.

You can also purchase a copy of the NNG Reference Manual. (It is published in both electronic and printed formats.) Purchases of the book help fund continued development of NNG.

Example Programs

Some demonstration programs have been created to help serve as examples. These are located in the demo directory.

Legacy Compatibility

A legacy libnanomsg compatible API is available, and while it offers less capability than the modern NNG API, it may serve as a transition aid. Please see nng_compat(3) for details.

from https://github.com/nanomsg/nng

----------

mangos is a pure Golang implementation of nanomsg's "Scalablilty Protocols".

mangos

        

Mangos™ is an implementation in pure Go of the SP (“Scalability Protocols”) messaging system. These are colloquially known as a “nanomsg”.

❗	The import path has changed! Please change any references from nanomsg.org/go/mangos/v2 to go.nanomsg.org/mangos/v3. The old v2 imports will still work for old applications, provided that a sufficiently modern version of Go is used. However, no further work will be done on v2.

Tip	Versions 1 and 2 of mangos were at different import locations. Those versions will still inter-operate with this version, except that within the same process the inproc transport can only be used by consumers using the same version of mangos.

The modern C implementation of the SP protocols is available as NNG™.

The original implementation of the SP protocols is available as nanomsg™.

Generally (modulo a few caveats) all of these implementations can inter-operate.

The design is intended to make it easy to add new transports with almost trivial effort, as well as new topologies (“protocols” in SP parlance.)

At present, all of the Req/Rep, Pub/Sub, Pair, Bus, Push/Pull, and Surveyor/Respondent patterns are supported. This project also supports an experimental protocol called Star.

Supported transports include TCP, inproc, IPC, WebSocket, WebSocket/TLS and TLS.

Basic interoperability with nanomsg and NNG has been verified (you can do so yourself with nanocat and macat) for all protocols and transports that NNG and nanomsg support, except for the ZeroTier transport and the PAIRv1 protocol, which are only supported in NNG at this time.

There are a number of projects that use these products together.

Documentation

For docs, see https://godoc.org/go.nanomsg.org/mangos or run:

$ godoc -http=:6060

then see http://localhost:6060/pkg/go.nanomsg.org/mangos/

Testing

This package supports internal self tests, which can be run in the idiomatic Go way. (Note that most of the tests are in a test subdirectory.)

$ go test go.nanomsg.org/mangos/v3/...

There are also internal benchmarks available:

$ go test -bench=. go.nanomsg.org/mangos/v3/test

Examples
Some examples are posted in the directories under examples/ in this project.
These examples are rewrites (in Go) of Tim Dysinger’s Getting Started with Nanomsg.
Running go doc in the example directories will yield information about how to run each example program.
Enjoy!
from https://github.com/nanomsg/mangos