Находки в опенсорсе

​​Zig is a general-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.

Features:
- Small, simple language
- Performance and Safety: Choose Two
- Zig competes with C instead of depending on it
- Order independent top level declarations
- Optional type instead of null pointers
- Manual memory management
- A fresh take on error handling
- Compile-time reflection and compile-time code execution
- Agnostic of blocking vs async I/O. Zig avoids function colors

https://ziglang.org/

​​One more cross-platform GUI library for #rust, but this one is inspired by #elm

Features:
- Simple, easy-to-use, batteries-included API
- Type-safe, reactive programming model
- Cross-platform support (Windows, macOS, Linux, and the Web)
- Responsive layout
- Built-in widgets (including text inputs, scrollables, and more!)
- Custom widget support (create your own!)
- Debug overlay with performance metrics
- First-class support for async actions (use futures!)
- Modular ecosystem split into reusable parts

https://github.com/hecrj/iced

​​#haskell STatic ANalyser

Stan is a command-line tool for analysing Haskell projects and outputting discovered vulnerabilities in a helpful way with possible solutions for detected problems. Stan is searching for not only performance or error-prone code pieces, but it also can help with establishing and applying best-practices from the whole Haskell ecosystem.

Although Haskell is a statically typed language, not all properties can be encoded in types. Even though GHC is quite a powerful compiler, it tries to be library-agnostic and provide only language-specific suggestions, while Stan uses the knowledge about the current state of the ecosystem and commonly used libraries.

You will find Stan helpful if you enjoy writing in Haskell, but want more guarantees from your code, not provided by the Haskell type system or GHC.

Stan is a configurable CLI tool. Besides the main feature of analysing Haskell projects statically, Stan has a list of features that make it unique, easy to use and flexible to configure:

- Pretty analysis results, including both HTML and terminal reports
- Suggestions and possible solutions for fixing the existing problems
- Analysing not only Haskell source code, but also information from the .cabal files
- Flexible runtime configuration via TOML and CLI

https://github.com/kowainik/stan

​​Build reactive applications with the #ruby on Rails tooling you already know and love.

You just discovered an exciting new way to build modern, reactive, real-time apps with Ruby on Rails. StimulusReflex eliminates the complexity imposed by full-stack frontend frameworks. And, it's fast.

Inspired by #elixir's LiveView feature.

https://github.com/hopsoft/stimulus_reflex

Personal opinion: one can better use Elixir and Phoenix if LiveView is required.

​​Layer Cake is a graphics framework for #svelte.

It uses the measurements of your target div and your data extents to create scales that stay synced on layout changes. Use these scales to organize multiple, mostly-reusable Svelte components, whether they be SVG, HTML, Canvas or WebGL. Since they all share the same coordinate space, you can build your graphic one layer at a time.

https://layercake.graphics/

#js

​​Newt DB, the amphibious database.

- In #python: enjoy the ease of working with your data as ordinary objects in memory.
- Data are moved in and out of memory as needed, so databases can be as large as needed.
- In Postgres: index and search your data using PostgreSQL, from within your application and externally.
- Within your application, search results may be returned as application objects, or as data, depending on your needs.
- Transactional and built on mature technology for reliability.

http://www.newtdb.org/en/latest/

​​Stop pasting company secrets into random websites!

It doesn't take a lot of text to tell you what Boop is. But here is a substantial amount of text anyway. It's a place for you to paste plain text and transform it if need be. It's what some of you use TextEdit, or maybe Notes, or maybe a blank unsaved .html file because that's what your editor defaults to when pressing ⌘+N and it's easier to do that than pick the proper file type, right? It's not like you needed syntax highlighting anyway.

Feature:
- Bring your own scripts
- Native AF
- Powered by Javascript
- Free and open source

https://github.com/IvanMathy/Boop

#swift

​​Nicene is a collection of extra Credo checks for linting #elixir code.

https://github.com/sketch-hq/nicene

​​A data-first #rust-native UI design toolkit.

Its main goal is to offer a polished user experience. There are many factors to this goal, including performance, a rich palette of interactions (hence a widget library to support them), and playing well with the native platform.

https://github.com/xi-editor/druid

It basically turns this code https://github.com/xi-editor/druid/blob/master/druid/examples/calc.rs into this layout:

​​Store your #js configs in one place and share between projects without any pain.

With sharec you can share and management configuration across projects, keep your code up to date and start new projects in one command.

https://github.com/lamartire/sharec

​​This is choose, a human-friendly and fast alternative to cut and (sometimes) awk written in #rust

Features:
- terse field selection syntax similar to Python's list slices
- negative indexing from end of line
- optional start/end index
- zero-indexed
- reverse ranges
- slightly faster than cut for sufficiently long inputs, much faster than awk
- regular expression field separators using Rust's regex syntax

https://github.com/theryangeary/choose

​​dbmate: A lightweight, framework-agnostic database migration tool.

Dbmate is a database migration tool, to keep your database schema in sync across multiple developers and your production servers.

It is a standalone command line tool, which can be used with #go, Node.js, Python, Ruby, PHP, or any other language or framework you are using to write database-backed applications. This is especially helpful if you are writing many services in different languages, and want to maintain some sanity with consistent development tools.

Features:

- Supports MySQL, PostgreSQL, and SQLite.
- Uses plain SQL for writing schema migrations.
- Migrations are timestamp-versioned, to avoid version number conflicts with multiple developers.
- Migrations are run atomically inside a transaction.
- Supports creating and dropping databases (handy in development or test).
- Supports saving a schema.sql file to easily diff schema changes in git.
- Database connection URL is definied using an environment variable or specified on the command line.
- Built-in support for reading environment variables from your .env file.
- Easy to distribute, single self-contained binary.

https://github.com/amacneil/dbmate

​​terminus: A terminal for a more modern age!

Terminus is a highly configurable terminal emulator for Windows, macOS and Linux

- Integrated SSH client and connection manager
- Theming and color schemes
- Fully configurable shortcuts
- Split panes
- Remembers your tabs
- PowerShell (and PS Core), WSL, Git-Bash, Cygwin, Cmder and CMD support
- Direct file transfer from/to SSH sessions via Zmodem
- Full Unicode support including double-width characters
- Doesn't choke on fast-flowing outputs
- Proper shell experience on Windows including tab completion (via Clink)

https://github.com/Eugeny/terminus

#ts

​​A declarative, efficient, and flexible #ts / #js library for building user interfaces.

It does not use a Virtual DOM. Instead it opts to compile its templates down to real DOM nodes and wrap updates in fine grained reactions. This way when your state updates only the code that depends on it runs.

- Real DOM with fine-grained updates (No Virtual DOM! No Dirty Checking Digest Loop!).
- Declarative data.
- Fast! Almost indistinguishable performance vs optimized painfully imperative vanilla DOM code. See Solid on JS Framework Benchmark.
- Small! Completely tree-shakeable Solid's compiler will only include parts of the library you use.
- Supports modern features like JSX, Fragments, Context, Portals, Suspense, SSR, Error Boundaries and Asynchronous Rendering.
- Built on TypeScript.
- Webcomponent friendly.
- Transparent debugging: a <div> is just a div.

https://github.com/ryansolid/solid

​​Run Mac in a Docker container! Run near native OSX-KVM in Docker! X11 Forwarding!

https://github.com/sickcodes/Docker-OSX

#devops

​​immudb is a lightweight, high-speed immutable database for systems and applications. Written in #go. With immudb you can track changes in sensitive data in your transactional databases and then record those changes permanently in a tamperproof immudb database. This allows you to keep an indelible history of sensitive data, for example debit/credit card transactions.

Traditional DB transactions and logs are hard to scale and are mutable. So there is no way to know for sure if your data has been compromised.

As such, immudb provides unparalleled insights retroactively of changes to your sensitive data, even if your perimeter has been compromised. immudb guarantees immutability by using a Merkle tree structure internally.

immudb gives you the same cryptographic verification of the integrity of data written with SHA-256 like a classic blockchain without the cost and complexity associated with blockchains today.

- immudb is immutable. You can add records, but never change or delete records.
- Data stored in immudb is cryptographically coherent and verifiable, like blockchains, just without all the complexity and at high speed.
- Anyone can get started with immudb in minutes. Whether you're using node.js, Java, Python, Go, .Net, or any other language. It's very easy to use and you can have your immutable database running in just a few minutes.
- Finally, immudb is Open Source. You can run it on premise, or in the cloud. It's completely free. immudb is governed by the Apache 2.0 License

https://github.com/codenotary/immudb

​​TiKV is an open-source, distributed, and transactional key-value database, originally created to complement TiDB. Unlike other traditional NoSQL systems, TiKV not only provides classical key-value APIs, but also transactional APIs with ACID compliance. Built in Rust and powered by Raft, TiKV was originally created to complement TiDB, a distributed HTAP database compatible with the MySQL protocol.

The design of TiKV ('Ti' stands for titanium) is inspired by some great distributed systems from Google, such as BigTable, Spanner, and Percolator, and some of the latest achievements in academia in recent years, such as the Raft consensus algorithm.

TiKV has the following key features:
- Geo-Replication: TiKV uses Raft and the Placement Driver to support Geo-Replication.
- Horizontal scalability: With PD and carefully designed Raft groups, TiKV excels in horizontal scalability and can easily scale to 100+ TBs of data.
- Consistent distributed transactions: Similar to Google's Spanner, TiKV supports externally-consistent distributed transactions.
- Coprocessor support: Similar to Hbase, TiKV implements a coprocessor framework to support distributed computing.
- Cooperates with TiDB: Thanks to the internal optimization, TiKV and TiDB can work together to be a compelling database solution with high horizontal scalability, externally-consistent transactions, support for RDBMS, and NoSQL design patterns.

https://github.com/tikv/tikv

#rust

​​Wren is a small, fast, class-based concurrent scripting language written in #c

Think Smalltalk in a Lua-sized package with a dash of Erlang and wrapped up in a familiar, modern syntax.

- Wren is small. The VM implementation is under 4,000 semicolons. You can skim the whole thing in an afternoon. It's small, but not dense. It is readable and lovingly-commented.
- Wren is fast. A fast single-pass compiler to tight bytecode, and a compact object representation help Wren compete with other dynamic languages.
- Wren is class-based. There are lots of scripting languages out there, but many have unusual or non-existent object models. Wren places classes front and center.
- Wren is concurrent. Lightweight fibers are core to the execution model and let you organize your program into an army of communicating coroutines.
- Wren is a scripting language. Wren is intended for embedding in applications. It has no dependencies, a small standard library, and an easy-to-use C API. It compiles cleanly as C99, C++98 or anything later.

https://wren.io/

​​A small #js library to create and animate annotations on a web page

Rough Notation uses RoughJS to create a hand-drawn look and feel. Elements can be annotated in a number of different styles. Animation duration and delay can be configured, or just turned off.

Rough Notation is about 3.2kb in size when gzipped, and the code is available on GitHub.

https://roughnotation.com/

​​kaffy: Powerfully simple admin package for phoenix applications.

Kaffy was created out of a need to have a powerfully simple, flexible, and customizable admin interface without the need to touch the current codebase. It was inspired by django’s lovely built-in admin app and rails’ powerful activeadmin gem.

https://aesmail.github.io/kaffy/

#elixir