├── .gitignore ├── CONTRIBUTING.md ├── LICENSE ├── README.md ├── _config.yml ├── awesomo.go └── languages ├── C#.md ├── C++.md ├── C.md ├── CLOJURE.md ├── COMMON_LISP.md ├── CRYSTAL.md ├── CSS.md ├── D.md ├── DART.md ├── ELIXIR.md ├── ELM.md ├── EMACS_LISP.md ├── ERLANG.md ├── GOLANG.md ├── HASKELL.md ├── HAXE.md ├── JAVA.md ├── JAVASCRIPT.md ├── KOTLIN.md ├── LUA.md ├── OCAML.md ├── PYTHON.md ├── R.md ├── RUBY.md ├── RUST.md ├── SCALA.md ├── SHELL.md ├── SOLIDITY.md ├── SVG.md ├── SWIFT.md └── TYPESCRIPT.md /.gitignore: -------------------------------------------------------------------------------- 1 | # Created by .ignore support plugin (hsz.mobi) 2 | .gitignore 3 | .idea/ 4 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing 2 | 3 | Your contributions are always welcome! 4 | 5 | ## Guidelines 6 | 7 | - Add one link per commit. 8 | 9 | - Add one commit per Pull Request. 10 | 11 | - Add the link: `- [**project-name**](http://example.com/) - The description ends with a period.` 12 | 13 | - Search previous suggestions before making a new one, as yours may be a duplicate. 14 | 15 | - Check your spelling and grammar. 16 | 17 | - Remove any trailing whitespace. 18 | 19 | - Send a PR with the reason why the library is really interesting. 20 | 21 | - Make sure the project that you want to add is not a mammoth's shit. 22 | 23 | 24 | 25 | ## What is mammoth's shit? 26 | Is old and unsupported projects where last commit was one or more years ago. 27 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | CC0 1.0 Universal 2 | 3 | Statement of Purpose 4 | 5 | The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work"). 6 | 7 | Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others. 8 | 9 | For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights. 10 | 11 | Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following: 12 | i. the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work; 13 | 14 | ii. moral rights retained by the original author(s) and/or performer(s); 15 | 16 | iii. publicity and privacy rights pertaining to a person's image or likeness depicted in a Work; 17 | 18 | iv. rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below; 19 | 20 | v. rights protecting the extraction, dissemination, use and reuse of data in a Work; 21 | 22 | vi. database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and 23 | 24 | vii. other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof. 25 | 26 | Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose. 27 | 28 | Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose. 29 | 30 | Limitations and Disclaimers. 31 | 32 | a. No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document. 33 | 34 | b. Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law. 35 | 36 | c. Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work. 37 | 38 | d. Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work. 39 | 40 | For more information, please see https://creativecommons.org/publicdomain/zero/1.0 41 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![awesomo](https://github.com/lk-geimfari/awesomo/assets/15812620/48c05000-9898-4603-882d-a143399f18cc)](https://github.com/lk-geimfari/awesomo) 2 | 3 | If you're interested in Open Source and thinking about joining the community of developers, you might find a suitable project here. 4 | 5 | # Languages 6 | 7 | - [C](languages/C.md) 8 | - [C#](languages/C%23.md) 9 | - [C++](languages/C%2B%2B.md) 10 | - [Clojure](languages/CLOJURE.md) 11 | - [Common Lisp](languages/COMMON_LISP.md) 12 | - [Crystal](languages/CRYSTAL.md) 13 | - [CSS](languages/CSS.md) 14 | - [D](languages/D.md) 15 | - [Dart](languages/DART.md) 16 | - [Elixir](languages/ELIXIR.md) 17 | - [Elm](languages/ELM.md) 18 | - [Emacs Lisp](languages/EMACS_LISP.md) 19 | - [Erlang](languages/ERLANG.md) 20 | - [Go](languages/GOLANG.md) 21 | - [Haskell](languages/HASKELL.md) 22 | - [Haxe](languages/HAXE.md) 23 | - [Java](languages/JAVA.md) 24 | - [JavaScript](languages/JAVASCRIPT.md) 25 | - [Kotlin](languages/KOTLIN.md) 26 | - [Lua](languages/LUA.md) 27 | - [OCaml](languages/OCAML.md) 28 | - [Python](languages/PYTHON.md) 29 | - [R](languages/R.md) 30 | - [Ruby](languages/RUBY.md) 31 | - [Rust](languages/RUST.md) 32 | - [Scala](languages/SCALA.md) 33 | - [Solidity](languages/SOLIDITY.md) 34 | - [Shell](languages/SHELL.md) 35 | - [SVG](languages/SVG.md) 36 | - [Swift](languages/SWIFT.md) 37 | - [TypeScript](languages/TYPESCRIPT.md) 38 | 39 | 40 | # Want to add an interesting project? 41 | 42 | - Simply [fork](https://github.com/lk-geimfari/awesomo/) this repository. 43 | - Add the project to the list using similar formatting of other projects. 44 | - Open [new pull request](https://github.com/lk-geimfari/awesomo/compare). 45 | 46 | :point_up: However, keep in mind that we don't accept *mammoth's shit*. Only active and interesting projects with good documentation are added. Dead and abandoned projects will be removed. 47 | 48 | 49 | # Want to support us? 50 | 51 | Just share this list with your friends on [Twitter](https://twitter.com/), [Facebook](https://www.facebook.com/), [Medium](http://medium.com) or somewhere else. 52 | 53 | # License 54 | 55 | `awesomo` by [@lk-geimfari](https://github.com/lk-geimfari) 56 | 57 | To the extent possible under law, the person who associated CC0 with `awesomo` has waived all copyright and related or neighboring rights to `awesomo`. 58 | 59 | You should have received a copy of the CC0 legalcode along with this work. If not, see https://creativecommons.org/publicdomain/zero/1.0/. 60 | -------------------------------------------------------------------------------- /_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-minimal -------------------------------------------------------------------------------- /awesomo.go: -------------------------------------------------------------------------------- 1 | package awesomo 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("Awesome!") 7 | } 8 | -------------------------------------------------------------------------------- /languages/C#.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**alba**](https://github.com/JasperFx/alba) is a tool for better integration testing against ASP.Net Core applications. 4 | 5 |
6 | 7 | [**AspNetKatana**](https://github.com/aspnet/AspNetKatana) is a flexible set of components for building and hosting OWIN-based web applications on .NET Framework. 8 | 9 |
10 | 11 | [**Atata**](https://github.com/atata-framework/atata) is an open source C#/.NET test automation full featured framework based on Selenium WebDriver. It uses fluent page object pattern with built-in logging. Atata Framework is extensible and contains a set of components, triggers and much more. 12 | 13 |
14 | 15 | [**AutoMapper**](https://github.com/AutoMapper/AutoMapper) is a convention-based object-object mapper in .NET. 16 | 17 |
18 | 19 | [**Avalonia**](https://github.com/AvaloniaUI/Avalonia/) is a cross-platform XAML-based UI 20 | framework providing a flexible styling system and supporting a wide range of Operating Systems 21 | such as Windows via .NET Framework and .NET Core, Linux via Xorg, macOS. Avalonia is ready 22 | for General-Purpose Desktop App Development. However, there may be some bugs and breaking 23 | changes as we continue along into this project's development. 24 | 25 | ## B 26 | 27 | [**benchmarks**](https://github.com/aspnet/benchmarks) - Benchmarks for ASP.NET Core including 28 | (but not limited to) scenarios from the TechEmpower Web Framework Benchmarks. 29 | 30 |
31 | 32 | [**Blazor**](https://github.com/aspnet/Blazor) is a .NET web framework using C#/Razor and HTML 33 | that runs in the browser with WebAssembly. 34 | 35 |
36 | 37 | [**BotBuilder**](https://github.com/Microsoft/BotBuilder) is one of three main components of the 38 | Microsoft Bot Framework. The Microsoft Bot Framework provides just what you need to build and 39 | connect intelligent bots that interact naturally wherever your users are talking, 40 | from text/SMS to Skype, Slack, Office 365 mail and other popular services. 41 | 42 |
43 | 44 | [**BuildTools**](https://github.com/aspnet/BuildTools) - Utilities used in the build system for 45 | projects that are used with ASP.NET Core and Entity Framework Core. 46 | 47 | ## C 48 | 49 | [**Cake**](https://github.com/cake-build/cake) (C# Make) is a build automation system with a C# DSL 50 | to do things like compiling code, copy files/folders, running unit tests, compress files and build 51 | NuGet packages. 52 | 53 |
54 | 55 | [**CefSharp**](https://github.com/cefsharp/CefSharp) is a .NET (WPF and Windows Forms) bindings 56 | for the Chromium Embedded Framework. 57 | 58 |
59 | 60 | [**ClosedXML**](https://github.com/ClosedXML/ClosedXML) ClosedXML is a .NET library for reading, 61 | manipulating and writing Excel 2007+ (.xlsx, .xlsm) files. It aims to provide an intuitive 62 | and user-friendly interface to dealing with the underlying OpenXML API. 63 | 64 |
65 | 66 | [**Common**](https://github.com/aspnet/Common) is a repository for shared files to be 67 | consumed across the ASPNET repos.[**Configuration**](https://github.com/aspnet/Configuration) 68 | is a framework for accessing Key/Value based configuration settings in an application. 69 | Includes configuration providers for command line arguments, environment variables, INI files, 70 | JSON files, and XML files. 71 | 72 |
73 | 74 | [**C-Sharp**](https://github.com/TheAlgorithms/C-Sharp) This repository contains 75 | algorithms and data structures implemented in C# for educational purposes. 76 | 77 |
78 | 79 | [**CppSharp**](https://github.com/mono/CppSharp) is a tool and set of libraries which 80 | allows programmers to use C/C++ libraries with high-level programming languages (such as C#). 81 | 82 | ## D 83 | 84 | [**Dapper**](https://github.com/StackExchange/dapper-dot-net) is a simple object mapper for 85 | .Net. Dapper is a NuGet library that you can add in to your project that will extend your 86 | IDbConnection interface. 87 | 88 |
89 | 90 | [**Docs**](https://github.com/aspnet/Docs) is a documentation for ASP.NET and ASP.NET 91 | Core https://docs.microsoft.com/aspnet 92 | 93 |
94 | 95 | [**DotNetty**](https://github.com/Azure/DotNetty) is a port of Netty, asynchronous 96 | event-driven network application framework for rapid development of maintainable high 97 | performance protocol servers & clients. 98 | 99 | ## E 100 | 101 | [**EntityFramework6**](https://github.com/aspnet/EntityFramework6) is an object-relational 102 | mapper that enables .NET developers to work with relational data using domain-specific objects. 103 | It eliminates the need for most of the data-access code that developers usually need to write. 104 | Entity Framework is actively developed by the Entity Framework team in collaboration with a 105 | community of open source developers. Together we are dedicated to creating the best 106 | possible data access experience for .NET developers. 107 | 108 |
109 | 110 | [**Extensions**](https://github.com/aspnet/Extensions) is an open-source, cross-platform set 111 | of APIs for commonly used programming patterns and utilities, such as dependency injection, 112 | logging, and app configuration. 113 | 114 |
115 | 116 | [**eShopOnContainers**](https://github.com/dotnet/eShopOnContainers) is a sample .NET Core reference 117 | application, powered by Microsoft, based on a simplified microservices architecture and Docker 118 | containers. 119 | 120 |
121 | 122 | [**eShopOnWeb**](https://github.com/dotnet/eShopOnWeb) is a sample ASP.NET Core reference application, 123 | powered by Microsoft, demonstrating a layered application architecture with monolithic deployment model 124 | 125 |
126 | 127 | [**EventFlow**](https://github.com/eventflow/EventFlow) is a basic CQRS+ES framework designed to be easy to use. 128 | 129 | 130 | ## I 131 | 132 | [**IdentityServer4**](https://github.com/IdentityServer/IdentityServer4) is built against ASP.NET Core 1.1 133 | using the RTM tooling that ships with Visual Studio 2017. This is the only configuration we support 134 | on the issue tracker. 135 | 136 |
137 | 138 | [**ILSpy**](https://github.com/icsharpcode/ILSpy) is the open-source .NET assembly browser and 139 | decompiler with support for PDB generation, ReadyToRun, Metadata (&more) - cross-platform! 140 | 141 | ## J 142 | 143 | [**Json.NET**](https://github.com/JamesNK/Newtonsoft.Json) is a personal open source project. 144 | Started in 2006, thousands of hours have been invested in refining and tuning Json.NET with the 145 | goal of making it not just the best JSON serializer for .NET but the best serializer for any 146 | computer language. 147 | 148 | ## L 149 | 150 | [**LibraryInstaller**](https://github.com/aspnet/LibraryInstaller) - Microsoft Library Installer. 151 | 152 |
153 | 154 | [**Live-Charts**](https://github.com/beto-rodriguez/Live-Charts) is a simple, flexible, interactive & 155 | powerful charts, maps and gauges for .Net http://lvcharts.net/ 156 | 157 | 158 | ## M 159 | 160 | [**MahApps.Metro**](https://github.com/MahApps/MahApps.Metro) is a toolkit for creating Metro / 161 | Modern UI styled WPF apps. 162 | 163 |
164 | 165 | [**MassTransit**](https://github.com/MassTransit/MassTransit) is a free, open-source distributed 166 | application framework for .NET. MassTransit makes it easy to create applications and services 167 | that leverage message-based, loosely-coupled asynchronous communication for higher availability, 168 | reliabililty, and scalability. 169 | 170 |
171 | 172 | [**MeredithCore**](https://github.com/whynotearth/meredith-core) A backend .net API which manages our database (postgres, google cloud). Data from this database is used by meredith-core to provide endpoints to any front end team. All content for websites, email marketing, ad buying, etc. is all stored in the same database, allowing easy content management for large brands and marketing agencies. 173 | 174 |
175 | 176 | [**MaterialDesignInXamlToolkit**](https://github.com/ButchersBoy/MaterialDesignInXamlToolkit) is a Google's Material Design in XAML & WPF, 177 | for C# & VB.Net. 178 | 179 |
180 | 181 | [**Mono**](https://github.com/mono/mono) is a software platform designed to allow developers 182 | to easily create cross platform applications. It is an open source implementation of Microsoft's 183 | .NET Framework based on the ECMA standards for C# and the Common Language Runtime. 184 | 185 |
186 | 187 | [**MudBlazor**](https://github.com/Garderoben/MudBlazor) is an ambitious Material Design 188 | component framework for Blazor with an emphasis on ease of use and clear structure. 189 | It is perfect for .NET developers who want to rapidly build web applications without having 190 | to struggle with CSS and Javascript. 191 | 192 | 193 | ## N 194 | 195 | [**NUnit**](https://github.com/nunit/nunit) is a unit-testing framework for all .NET languages. 196 | Initially ported from JUnit, the current production release, version 3, has been completely 197 | rewritten with many new features and support for a wide range of .NET platforms. 198 | 199 | ## O 200 | 201 | [**Ocelot**](https://github.com/TomPallister/Ocelot) is an API Gateway created using .NET core. 202 | 203 |
204 | 205 | [**OpenTK**](https://github.com/opentk/opentk) is a fast, low-level C# binding for OpenGL, 206 | OpenGL ES and OpenAL. It runs on all major platforms and powers hundreds of apps, games and 207 | scientific research. 208 | 209 | Use OpenTK to add cross-platform 3d graphics, audio, compute and haptics to your C# application. 210 | Integrate it into your existing user interface or use it standalone without any external dependencies. 211 | 212 |
213 | 214 | [**OptiKey**](https://github.com/OptiKey/OptiKey) is an assistive on-screen keyboard which runs 215 | on Windows. It is designed to be used with an eye-tracking device to assist with keyboard and 216 | mouse control for those living with motor and speech limitations, such as 217 | Amyotrophic Lateral Sclerosis (ALS) / Motor Neuron Disease (MND). 218 | 219 | ## P 220 | 221 | [**PostProcessing**](https://github.com/Unity-Technologies/PostProcessing) is a new unity 222 | post-processing stack is an über effect that combines a complete set of image effects into a 223 | single post-process pipeline. 224 | 225 |
226 | 227 | [**PowerShell**](https://github.com/PowerShell/PowerShell) is a cross-platform 228 | (Windows, Linux, and macOS) automation and configuration tool/framework that works well with 229 | your existing tools and is optimized for dealing with structured data (e.g. JSON, CSV, XML, etc.), 230 | REST APIs, and object models. It includes a command-line shell, an associated scripting language 231 | and a framework for processing cmdlets. 232 | 233 | ## Q 234 | 235 | [**Quartz Enterprise Scheduler .NET**](https://github.com/quartznet/quartznet) is an opensource 236 | project aimed at creating a free-for-commercial use Job Scheduler, with 'enterprise' features. 237 | 238 | ## R 239 | 240 | [**RabbitMQ .NET client**](https://github.com/rabbitmq/rabbitmq-dotnet-client) for .NET Core and .NET 4.5.1+. 241 | 242 |
243 | 244 | [**react-native-windows**](https://github.com/Microsoft/react-native-windows) is a framework 245 | for building native UWP and WPF apps with React. http://facebook.github.io/react-native/ 246 | 247 |
248 | 249 | [**ResponseCaching**](https://github.com/aspnet/ResponseCaching) is an ASP.NET Core middleware 250 | for caching responses. 251 | 252 |
253 | 254 | [**Roslyn**](https://github.com/dotnet/roslyn) provides open-source C# and Visual Basic 255 | compilers with rich code analysis APIs. It enables building code analysis tools with the 256 | same APIs that are used by Visual Studio. 257 | 258 | ## S 259 | 260 | [**Scaffolding**](https://github.com/aspnet/Scaffolding) - ASP.NET Scaffolding enables 261 | generating boilerplate code for web applications to speed up development. 262 | 263 |
264 | 265 | [**Shadowsocks for Windows**](https://github.com/shadowsocks/shadowsocks-windows) is a secure 266 | socks5 proxy, designed to protect your Internet traffic. 267 | 268 |
269 | 270 | [**SimpleInjector**](https://github.com/simpleinjector/SimpleInjector) is an open source dependency 271 | injection (DI) library for .NET. 272 | 273 |
274 | 275 | [**StaticFiles**](https://github.com/aspnet/StaticFiles) - This repo contains middleware for 276 | handling requests for file system resources including files and directories. 277 | 278 | ## T 279 | 280 | [**Topshelf**](https://github.com/Topshelf/Topshelf) is a framework for hosting services 281 | written using the .NET framework. The creation of services is simplified, allowing developers 282 | to create a simple console application that can be installed as a service using Topshelf. 283 | The reason for this is simple: It is far easier to debug a console application than a service. 284 | And once the application is tested and ready for production, Topshelf makes it easy to install 285 | the application as a service. 286 | 287 | ## W 288 | 289 | [**Web Markup Minifier**](https://github.com/Taritsyn/WebMarkupMin) is .NET library that contains 290 | a set of markup minifiers. The objective of this project is to improve the performance of web 291 | applications by reducing the size of HTML, XHTML and XML code. 292 | 293 |
294 | 295 | [**websdk**](https://github.com/aspnet/websdk) - ASP.NET Web Sdk targets contains the tasks, 296 | targets and packages required to build and publish Web Applications. 297 | 298 |
299 | 300 | [**Wox**](https://github.com/Wox-launcher/Wox) is a launcher for Windows, an alternative to Alfred and Launchy. 301 | 302 |
303 | 304 | [**websocket-sharp**](https://github.com/sta/websocket-sharp) A C# implementation of the WebSocket 305 | protocol client and server. 306 | 307 | ## X 308 | 309 | [**XUnit**](https://github.com/xunit/xunit) is a free, open source, community-focused unit testing 310 | tool for the .NET Framework. Written by the original inventor of NUnit v2, xUnit.net is the latest 311 | technology for unit testing C#, F#, VB.NET and other .NET languages. xUnit.net works with ReSharper, 312 | CodeRush, TestDriven.NET and Xamarin. 313 | -------------------------------------------------------------------------------- /languages/C++.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**ArangoDB**](https://github.com/arangodb/arangodb) is a multi-model, open-source database with flexible data models for documents, graphs, and key-values. Build high performance applications using a convenient SQL-like query language or JavaScript extensions. Use ACID transactions if you require them. Scale horizontally with a few mouse clicks. 4 | 5 | The supported data models can be mixed in queries and allow ArangoDB to be the aggregation point for your data. 6 | 7 |
8 | 9 | [**AREG SDK**](https://github.com/aregtech/areg-sdk/) is an interface-centric real-time asynchronous communication engine to enable [distributed-](https://en.wikipedia.org/wiki/Distributed_computing) and [mist-](https://csrc.nist.gov/publications/detail/sp/500-325/final)computing, where Things interact and provide services, as if they act like thin distributed servers. 10 | 11 | Traditionally, devices are connected clients to stream data to the cloud or fog servers for further processing. Since data is generated and collected at the edge of the network (mist network), it makes sense to change the role of connected Things and provide network accessible (_Public_) services directly on devices. This extends _Cloud_ to the extreme edge. 12 | 13 | ## B 14 | 15 | [**Bitcoin**](https://bitcoin.org/) is an innovative payment network and a new kind of money. Bitcoin uses peer-to-peer technology to operate with no central authority or banks; managing transactions and the issuing of bitcoins is carried out collectively by the network. Bitcoin is open-source; its design is public, nobody owns or controls Bitcoin and [everyone can take part](https://bitcoin.org/en/support-bitcoin). Through many of its unique properties, Bitcoin allows exciting uses that could not be covered by any previous payment system. 16 | 17 |
18 | 19 | [**Blender**](https://github.com/blender/blender) is the free and open source 3D creation suite. It supports the entirety of the 3D pipeline-modeling, rigging, animation, simulation, rendering, compositing, motion tracking and video editing. 20 | 21 | ## C 22 | 23 | 24 | [**Catch2**](https://github.com/catchorg/Catch2) is a multi-paradigm test framework for unit-tests, TDD and BDD. It is primarily distributed as a single header file, although certain extensions may require additional headers. 25 | 26 |
27 | 28 | [**Chromium**](http://www.chromium.org) and is used by the [Atom 29 | editor](https://github.com/atom/atom) and many other [apps](http://electron.atom.io/apps). 30 | 31 | ## D 32 | 33 | [**Dear Imgui**](https://github.com/ocornut/imgui) is a bloat-free graphical user interface library. It outputs optimized vertex buffers that you can render anytime in your 3D-pipeline enabled application. It is fast, portable, renderer agnostic and self-contained (no external dependencies). 34 | 35 | Dear ImGui is designed to enable fast iterations and to empower programmers to create content creation tools and visualization / debug tools (as opposed to UI for the average end-user). It favors simplicity and productivity toward this goal. 36 | 37 |
38 | 39 | [**Defold**](https://github.com/defold/defold) is a free to use, source available, game engine with a developer-friendly license. Defold is owned and developed by the Defold Foundation. 40 | 41 | ## E 42 | 43 | [**Electron**](https://github.com/electron/electron) lets you write cross-platform desktop applications 44 | using JavaScript, HTML and CSS. It is based on [Node.js](https://nodejs.org/) and 45 | 46 | ## G 47 | 48 | [**Godot**](https://github.com/godotengine/godot) Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so that users can focus on making games without having to reinvent the wheel. Games can be exported in one click to a number of platforms, including the major desktop platforms (Linux, Mac OSX, Windows) as well as mobile (Android, iOS) and web-based (HTML5) platforms. 49 | 50 | ## I 51 | 52 | [**i2pd**](https://github.com/PurpleI2P/i2pd) is a full-featured C++ implementation of I2P client. 53 | 54 | I2P (Invisible Internet Protocol) is a universal anonymous network layer. All communications over I2P are anonymous and end-to-end encrypted, participants don't reveal their real IP addresses. I2P allows people from all around the world to communicate and share information without restrictions. 55 | 56 | ## L 57 | 58 | [**Lina Engine**](https://github.com/inanevin/LinaEngine) is a lightweight and ECS based open-source game engine. Initially it's a research project and is aimed to be a basis of development for more open-source game engine projects. Lina's architecture is designed to be as modular as possible and it focuses on creating replacable modules to customize for project-specific needs, rather than stacking thousands of features into one framework. 59 | 60 |
61 | 62 | [**Lithium**](https://github.com/matt-42/lithium) is the fastest open-source HTTP framework written in c++17. Lithium HTTP server and SQL drivers are benchmarked againts 200+ other framesworks at [TechEmpower](https://www.techempower.com/benchmarks) . As of November 2020, it is ranked first. Pre-2010 C++ was a pretty low-level language and zero-runtime-cost abstractions where only possible using complex template meta-programming tricks. The C++ standard committee addressed those issues by publishing new C++ standard, making C++ programs much more simpler and fun to write. These recent language evolutions has created inside the language a C++ subset that is easy to grasp for beginners and less error prone than C++ itself: using RAII instead of manual memory management, using constexpr instead of template meta-programming, etc... 63 | Could this subset of C++ lead to a web framework that is as easy to grasp than javascript alternatives while keeping the performances of C++ ? 64 | The goal of Lithium is to prove that this is feasible. 65 | 66 | ## M 67 | 68 | [**MXNet**](https://github.com/dmlc/mxnet) is a deep learning framework designed for both efficiency and flexibility. It allows you to mix the flavours of symbolic programming and imperative programming to maximize efficiency and productivity. In its core, a dynamic dependency scheduler that automatically parallelizes both symbolic and imperative operations on the fly. A graph optimization layer on top of that makes symbolic execution fast and memory efficient. The library is portable and lightweight, and it scales to multiple GPUs and multiple machines. 69 | 70 | ## O 71 | 72 | [**Ogre3D**](https://www.ogre3d.org/) is one of the most popular open-source graphics rendering engines, and has been used in a large number of production projects, in such diverse areas as games, simulators, educational software, interactive art, scientific visualisation, and others. 73 | 74 |
75 | 76 | [**OpenCV**](http://opencv.org) (Open Source Computer Vision Library) is an open source computer vision and machine learning software library. OpenCV was built to provide a common infrastructure for computer vision applications and to accelerate the use of machine perception in the commercial products. Being a BSD-licensed product, OpenCV makes it easy for businesses to utilize and modify the code. 77 | 78 |
79 | 80 | [**openFrameworks**](https://github.com/openframeworks/openFrameworks) is an open source C++ toolkit for creative coding. It includes tools for 2D/3D graphics, audio, and video components along with many addons for integrations with everything from XBOX Kinects to OpenCV. 81 | 82 | The code is written to be massively cross-compatible. Right now they support five operating systems (Windows, OSX, Linux, iOS, Android) and four IDEs (XCode, Code::Blocks, and Visual Studio and Eclipse). The API is designed to be minimal and easy to grasp. 83 | 84 |
85 | 86 | [**Overload**](https://github.com/adriengivry/Overload) is an alternative game engine, inspired by industry standards, initiated by Benjamin VIRANIN, Max BRUN and Adrien GIVRY. Overload is now a community project, opened to any contribution. 87 | 88 | Overload pillars are: 89 | 90 | * Simplicity 91 | * Documentation 92 | * High-quality modern C++ code 93 | 94 | ## P 95 | 96 | [**Pony**](https://github.com/ponylang/ponyc) is an open-source, actor-model, capabilities-secure, high performance programming language. 97 | 98 | Hello World in Pony: 99 | 100 | ```pony 101 | actor Main 102 | new create(env: Env) => 103 | env.out.print("Hello, world!") 104 | ``` 105 | 106 |
107 | 108 | [**Proxygen**](https://github.com/facebook/proxygen). This project comprises the core C++ HTTP abstractions used at Facebook. Internally, it is used as the basis for building many HTTP servers, proxies, and clients. This release focuses on the common HTTP abstractions and our simple HTTPServer framework. Future releases will provide simple client APIs as well. The framework supports HTTP/1.1, SPDY/3, SPDY/3.1, and HTTP/2. The goal is to provide a simple, performant, and modern C++ HTTP library. 109 | 110 | ## R 111 | 112 | [**Redis Desktop Manager**](https://github.com/uglide/RedisDesktopManager) — an Open source cross-platform Redis Desktop Manager based on Qt 5. 113 | 114 |
115 | 116 | [**RethinkDB**](https://github.com/rethinkdb/rethinkdb)   —  the first open-source scalable database built for realtime applications. It exposes a new database access model — instead of polling for changes, the developer can tell the database to continuously push updated query results to applications in realtime. RethinkDB allows developers to build scalable realtime apps in a fraction of the time with less effort. 117 | 118 |
119 | 120 | [**Robomongo**](https://github.com/paralect/robomongo) is a shell-centric cross-platform MongoDB management tool. Unlike most other MongoDB admin UI tools, Robomongo embeds the actual mongo shell in a tabbed interface with access to a shell command line as well as GUI interaction. 121 | 122 | ## S 123 | 124 | [**SDL**](https://www.libsdl.org/) (Simple DirectMedia Layer) is a cross-platform development library designed to provide low level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D. It is used by video playback software, emulators, and popular games including Valve's award winning catalog and many Humble Bundle games. Officially supports Windows, Mac OS X, Linux, iOS, and Android. Support for other platforms may be found in the source code. SDL 2.0 is distributed under the zlib license. This license allows you to use SDL freely in any software. 125 | 126 | ## T 127 | 128 | [**TensorFlow**](https://github.com/tensorflow/tensorflow) is an end-to-end open source platform for machine learning. It has a comprehensive, flexible ecosystem of tools, libraries, and community resources that lets researchers push the state-of-the-art in ML and developers easily build and deploy ML powered applications. 129 | 130 | ## W 131 | 132 | [**µWS**](https://github.com/uWebSockets/uWebSockets) is one of the most lightweight, efficient & scalable WebSocket server implementations available. It features an easy-to-use, fully async object-oriented interface and scales to millions of connections using only a fraction of memory compared to the competition. While performance and scalability are two of our top priorities, we consider security, stability and standards compliance paramount. License is zlib/libpng (very permissive & suits commercial applications). 133 | 134 |
135 | 136 | [**Wicked Engine**](https://github.com/turanszkij/WickedEngine) is an open-source game engine written in C++. The main focus is to be easy to set up and use, light weight, high performance, and graphically advanced. The full source code is provided with the MIT license, which means, anyone is free to use it for anything without additional considerations. 137 | 138 |
139 | 140 | [**wxWidgets**](https://github.com/wxWidgets/wxWidgets) is a C++ library that lets developers create applications for Windows, macOS, Linux and other platforms with a single code base. It has popular language bindings for Python, Perl, Ruby and many other languages, and unlike other cross-platform toolkits, wxWidgets gives applications a truly native look and feel because it uses the platform's native API rather than emulating the GUI. It's also extensive, free, open-source and mature. 141 | -------------------------------------------------------------------------------- /languages/C.md: -------------------------------------------------------------------------------- 1 | ## G 2 | 3 | [**GIMP**](https://github.com/GNOME/gimp) is a cross-platform image editor available for GNU/Linux, OS X, Windows and more operating systems. It is free software, you can change its source code and distribute your changes. 4 | 5 | Whether you are a graphic designer, photographer, illustrator, or scientist, GIMP provides you with sophisticated tools to get your job done. You can further enhance your productivity with GIMP thanks to many customization options and 3rd party plugins. 6 | 7 | ## H 8 | 9 | [**Hashcat**](https://github.com/hashcat/hashcat) hashcat is the world's fastest and most advanced password recovery utility, supporting five unique modes of attack for over 200 highly-optimized hashing algorithms. hashcat currently supports CPUs, GPUs, and other hardware accelerators on Linux, Windows, and macOS, and has facilities to help enable distributed password cracking. 10 | 11 | 12 | ## K 13 | 14 | [**Kore**](https://github.com/jorisvink/kore) is an easy to use web application framework for writing scalable web APIs in C. Its main goals are security, scalability and allowing rapid development and deployment of such APIs. 15 | 16 | ## L 17 | 18 | [**libuv**](https://github.com/libuv/libuv) is a multi-platform support library with a focus on asynchronous I/O. It was primarily developed for use by Node.js, but it's also used by Luvit, Julia, pyuv, and others. 19 | 20 | Feature highlights: 21 | 22 | * Full-featured event loop backed by epoll, kqueue, IOCP, event ports. 23 | * Asynchronous TCP and UDP sockets 24 | * Asynchronous DNS resolution 25 | * Asynchronous file and file system operations 26 | * File system events 27 | * ANSI escape code controlled TTY 28 | * IPC with socket sharing, using Unix domain sockets or named pipes (Windows) 29 | * Child processes 30 | * Thread pool 31 | * Signal handling 32 | * High resolution clock 33 | * Threading and synchronization primitives 34 | 35 | --- 36 | 37 | [**Lwan**](https://github.com/lpereira/lwan/) is a high-performance & scalable web server for glibc/Linux 38 | platforms. 39 | 40 | In development for almost 4 years, Lwan was until now a personal research 41 | effort that focused mostly on building a **solid infrastructure** for 42 | a lightweight and speedy web server: 43 | 44 | - Low memory footprint (~500KiB for 10k idle connections) 45 | - Minimal memory allocations & copies 46 | - Minimal system calls 47 | - Hand-crafted HTTP request parser 48 | - Files are served using the most efficient way according to their size 49 | - No copies between kernel and userland for files larger than 16KiB 50 | - Smaller files are sent using vectored I/O of memory-mapped buffers 51 | - Header overhead is considered before compressing small files 52 | - Mostly wait-free multi-threaded design 53 | - Diminute code base with roughly 7200 lines of C code 54 | 55 | It is now transitioning into a fully working, capable HTTP server. It is 56 | not, however, as feature-packed as other popular web servers. But it is 57 | [free software](http://www.gnu.org/philosophy/free-sw.html), so scratching 58 | your own itches and making Lwan hum the way you want it to is possible. 59 | 60 | ## N 61 | 62 | [**Nchan**](https://github.com/slact/nchan) is a scalable, flexible pub/sub server for the modern web, built as a module for the Nginx web server. It can be configured as a standalone server, or as a shim between your application and hundreds, thousands, or millions of live subscribers. It can buffer messages in memory, on-disk, or via Redis. All connections are handled asynchronously and distributed among any number of worker processes. It can also scale to many Nginx servers with Redis. 63 | 64 |
65 | 66 | [**netdata**](https://github.com/firehol/netdata) is a system for distributed real-time performance and health monitoring. It provides unparalleled insights, in real-time, of everything happening on the system it runs (including applications such as web and database servers), using modern interactive web dashboards. 67 | 68 | netdata is fast and efficient, designed to permanently run on all systems (physical & virtual servers, containers, IoT devices), without disrupting their core function. 69 | 70 |
71 | 72 | [**NumPy**](https://github.com/numpy/numpy) is the fundamental package needed for scientific computing with Python. 73 | This package contains: 74 | 75 | * a powerful N-dimensional array object 76 | * sophisticated (broadcasting) functions 77 | * tools for integrating C/C++ and Fortran code 78 | * useful linear algebra, Fourier transform, and random number capabilities. 79 | 80 | It derives from the old Numeric code base and can be used as a replacement for Numeric. It also adds the features introduced by numarray and can be used to replace numarray. 81 | 82 | 83 | ## S 84 | 85 | [**Skynet**](https://github.com/cloudwu/skynet) is a lightweight online game framework, and it can be used in many other fields. 86 | 87 | --- 88 | 89 | [**StringZilla**](https://github.com/ashvardanian/stringzilla) is a fast string processing library using SIMD Assembly instructions on Arm Neon and x86 AVX2 & AVX-512-capable chips to accelerate search, sorting, grouping, hashing, edit distances, and even alignment scores. It's implemented mostly in C, and has bindings to C++, Python, Rust, and Swift, among other languages. 90 | -------------------------------------------------------------------------------- /languages/CLOJURE.md: -------------------------------------------------------------------------------- 1 | ## 4 2 | 3 | [**4clojure**](https://github.com/4clojure/4clojure) is an interactive problem website for learning Clojure 4 | 5 | ## A 6 | 7 | [**Aleph**](https://github.com/ztellman/aleph) exposes data from the network as a Manifold stream, which can easily be transformed into a java.io.InputStream, core.async channel, Clojure sequence, or many other byte representations. It exposes simple default wrappers for HTTP, TCP, and UDP, but allows access to full performance and flexibility of the underlying Netty library. 8 | 9 | ## B 10 | 11 | [**Babashka**](https://github.com/borkdude/babashka) is a Clojure babushka for the grey areas of Bash. 12 | 13 | **Goals**: 14 | 15 | * **Fast starting** Clojure scripting alternative for JVM Clojure 16 | * **Easy installation:** grab the self-contained binary and run. No JVM needed. 17 | * **Familiar:** targeted at JVM Clojure users 18 | * **Cross-platform:** supports linux, macOS and Windows 19 | * **Interop** with commonly used classes (`System`, `File`, `java.time.*`, `java.nio.*`) 20 | * **Multi-threading** support (`pmap`, `future`) 21 | * **Batteries included** (tools.cli, cheshire, ...) 22 | 23 | ## C 24 | 25 | [**Cheshire**](https://github.com/dakrone/cheshire) is fast JSON encoding, based off of clj-json and clojure-json, with additional features like Date/UUID/Set/Symbol encoding and SMILE support. 26 | 27 | Encoding example: 28 | ```clojure 29 | ;; generate some json 30 | (generate-string {:foo "bar" :baz 5}) 31 | 32 | ;; write some json to a stream 33 | (generate-stream {:foo "bar" :baz 5} (clojure.java.io/writer "/tmp/foo")) 34 | 35 | ;; generate some SMILE 36 | (generate-smile {:foo "bar" :baz 5}) 37 | 38 | ;; generate some JSON with Dates 39 | ;; the Date will be encoded as a string using 40 | ;; the default date format: yyyy-MM-dd'T'HH:mm:ss'Z' 41 | (generate-string {:foo "bar" :baz (java.util.Date. 0)}) 42 | 43 | ;; generate some JSON with Dates with custom Date encoding 44 | (generate-string {:baz (java.util.Date. 0)} {:date-format "yyyy-MM-dd"}) 45 | 46 | ;; generate some JSON with pretty formatting 47 | (generate-string {:foo "bar" :baz {:eggplant [1 2 3]}} {:pretty true}) 48 | ;; { 49 | ;; "foo" : "bar", 50 | ;; "baz" : { 51 | ;; "eggplant" : [ 1, 2, 3 ] 52 | ;; } 53 | ;; } 54 | 55 | ;; generate JSON escaping UTF-8 56 | (generate-string {:foo "It costs £100"} {:escape-non-ascii true}) 57 | ;; => "{\"foo\":\"It costs \\u00A3100\"}" 58 | 59 | ;; generate JSON and munge keys with a custom function 60 | (generate-string {:foo "bar"} {:key-fn (fn [k] (.toUpperCase (name k)))}) 61 | ;; => "{\"FOO\":\"bar\"}" 62 | ``` 63 | 64 |
65 | 66 | [**clojure-lsp**](https://github.com/clojure-lsp/clojure-lsp) is a [LSP](https://microsoft.github.io/language-server-protocol/) server implementation for multiple IDEs written in clojure 67 | 68 |
69 | 70 | [**clojurescript**](https://github.com/clojure/clojurescript) is a compiler for Clojure that targets JavaScript. It is designed to emit JavaScript code which is compatible with the advanced compilation mode of the Google Closure optimizing compiler. 71 | Official web site: [https://clojurescript.org](https://clojurescript.org/) 72 | 73 |
74 | 75 | [**clojure-koans**](https://github.com/functional-koans/clojure-koans) are a fun way to get started with Clojure - no experience assumed or required. Clojure Koans are exercises meant to initiate you to the mysteries of the Clojure language. By following along the path set before you, you will touch on all the major aspects of the language, from simple datatypes to macros, from tail recursion to Java interoperability. Many will find Clojure quite different from any programming language they've used before. The koans' incremental, interactive approach to learning the language will help make the transition feel natural. By the time you are finished with them, Clojure will not be so mysterious at all. 76 | 77 |
78 | 79 | [**clojupyter**](https://github.com/clojupyter/clojupyter) is a Jupyter kernel for Clojure - run Clojure code in Jupyter Lab, Notebook and Console. 80 | 81 |
82 | 83 | [**compojure**](https://github.com/weavejester/compojure)  —  a small routing library for Ring that allows web applications to be composed of small, independent parts. 84 | 85 | This small Compojure application demonstrates creating a Ring handler from two routes: 86 | 87 | ```clojure 88 | (ns hello-world.core 89 | (:require [compojure.core :refer :all] 90 | [compojure.route :as route])) 91 | (defroutes app 92 | (GET "/" [] "

Hello World

") 93 | (route/not-found "

Page not found

")) 94 | ``` 95 | 96 | --- 97 | [**Cryogen**](http://cryogenweb.org/) is a simple static site generator built with Clojure. It's shipped on Leiningen so setup is fuss free and there's no need to mess with databases or other CMS systems. 98 | 99 |
100 | 101 | ## D 102 | 103 | [**Datascript**](https://github.com/tonsky/datascript)  —  an immutable in-memory database and Datalog query engine in Clojure and ClojureScript. 104 | 105 |
106 | 107 | ## E 108 | 109 | [Emmy](https://github.com/mentat-collective/emmy) is a Clojure(Script) implementation of the scmutils system for math and physics investigations in the Clojure and ClojureScript languages. Emmy provides facilities for 110 | 111 | - [symbolic 112 | computation](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/data-types/symbolic-expressions), 113 | including state of the art TeX rendering and [expression 114 | simplification](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/simplification) 115 | - [automatic](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/calculus/automatic-differentiation), 116 | [numerical](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/numerical-methods/numerical-derivative) 117 | and 118 | [symbolic](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/calculus/automatic-differentiation) 119 | differentiation 120 | - [numerical integration and 121 | optimization](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/numerical-methods) 122 | - investigations in [differential 123 | geometry](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/textbooks/functional-differential-geometry) 124 | and [Lagrangian and Hamiltonian 125 | mechanics](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/textbooks/structure-and-interpretation-of-classical-mechanics) 126 | 127 | And implementations of many different [mathematical 128 | objects](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/data-types), all built 129 | on a tower of [generic, extensible mathematical 130 | operations](https://cljdoc.org/d/org.mentat/emmy/CURRENT/doc/basics/generics). 131 | 132 |
133 | 134 | ## H 135 | 136 | --- 137 | [**http-kit**](https://github.com/http-kit/http-kit) is a minimalist, event-driven, high-performance Clojure HTTP server/client library with WebSocket and asynchronous support. 138 | 139 | Server: 140 | ```clojure 141 | (defn async-handler [ring-request] 142 | ;; unified API for WebSocket and HTTP long polling/streaming 143 | (with-channel ring-request channel ; get the channel 144 | (if (websocket? channel) ; if you want to distinguish them 145 | (on-receive channel (fn [data] ; two way communication 146 | (send! channel data))) 147 | (send! channel {:status 200 148 | :headers {"Content-Type" "text/plain"} 149 | :body "Long polling?"})))) 150 | 151 | (run-server async-handler {:port 8080}) ; Ring server 152 | ``` 153 | 154 | Client: 155 | ```clojure 156 | ;; start concurrent requests, get promise, half the waiting time 157 | (let [response1 (http-kit/get "http://http-kit.org/") 158 | response2 (http-kit/get "http://clojure.org/")] 159 | ;; Handle responses one-by-one, blocking as necessary 160 | ;; Other keys :headers :body :error :opts 161 | (println "response1's status: " (:status @response1)) 162 | (println "response2's status: " (:status @response2))) 163 | ``` 164 | 165 | ## J 166 | 167 | [**Jepsen**](https://github.com/jepsen-io/jepsen) is a Clojure library. A test is a Clojure program which uses the Jepsen library to set up a distributed system, run a bunch of operations against that system, and verify that the history of those operations makes sense. Jepsen has been used to verify everything from eventually-consistent commutative databases to linearizable coordination systems to distributed task schedulers. It can also generate graphs of performance and availability, helping you characterize how a system responds to different faults. See aphyr.com for examples of the sorts of analyses you can carry out with Jepsen. 168 | 169 | ## K 170 | 171 | [**Klipse**](https://github.com/viebel/klipse) is a simple client-side code evaluator pluggable on any web page: clojure, ruby, javascript, python, scheme, es2017, jsx, brainfuck, c++, reagent and a clojure[script] web repl. 172 | 173 | Checkout [Klipse blog with interactive code snippets](http://blog.klipse.tech/) and the [KLIPSE clojure web repl](http://app.klipse.tech/). 174 | 175 | ## L 176 | 177 | [**Luminus**](http://www.luminusweb.net/) is a Clojure micro-framework based on a set of lightweight libraries. It aims to provide a robust, scalable, and easy to use platform. 178 | 179 | ## M 180 | 181 | [**Metabase**](https://github.com/metabase/metabase) is the easy, open source way for everyone in your company to ask questions and learn from data. 182 | 183 | ## O 184 | 185 | [**Overtone**](https://github.com/overtone/overtone) is an Open Source toolkit for designing synthesizers and collaborating with music. 186 | 187 | 888 188 | 888 189 | _ooooooooo._ 888 190 | ,o888PP""""PP88 .d88b. 888 888 .d88b. 888d888 888888 .d88b. 88888b. .d88b. 191 | d88P'' ' d88""88b 888 888 d8P Y8b 888P" 888 d88""88b 888 "88b d8P Y8b 192 | ,88P 88 88 Y88 88P 88888888 888 888 88 88 888 888 88888888 193 | ,88 Y88..88P Y8bd8P Y8b. 888 Y88b. Y88..88P 888 888 Y8b. 194 | ,88' "Y88P" Y88P "Y8888 888 "Y888 "Y88P" 888 888 "Y8888 195 | d8P 196 | d8b 88[ 197 | `88 J88 198 | Y8b ,88' 199 | Y8b. d88' 200 | `Y8b._ _o88P 201 | `Y888oo.____ooo888P' 202 | '"PP888888PP'' 203 | 204 | 205 | ## P 206 | 207 | [**Pedestal**](https://github.com/pedestal/pedestal) is a set of libraries written in Clojure that aims to bring both the language and its principles (Simplicity, Power and Focus) to server-side development. 208 | 209 | [Here](https://github.com/pedestal/pedestal/tree/master/samples) you can find samples. 210 | 211 | ## Q 212 | 213 | [**Quil**](https://github.com/quil/quil) is a Clojure/ClojureScript library for creating interactive drawings and animations. 214 | 215 | ## S 216 | 217 | The [`secrets`](https://github.com/lk-geimfari/secrets.clj) is a library designed to generate cryptographically strong random numbers suitable for managing data such as passwords, account authentication, security tokens, and related secrets. 218 | 219 | The [`secrets`](https://github.com/lk-geimfari/secrets.clj) is an implementation of the [`secrets`](https://docs.python.org/3/library/secrets.html) 220 | module from Python's standard library for Clojure. 221 | 222 | See [«Recipes and best practices»](#recipes-and-best-practices) for usage examples. 223 | 224 |
225 | 226 | [**Selmer**](https://github.com/yogthos/Selmer). A fast, Django inspired template system for Clojure. 227 | 228 | Selmer templates consist of plain text that contains embedded expression and filter tags. While Selmer 229 | is primarily meant for HTML generation, it can be used for templating any text. 230 | 231 | Selmer compiles the template files and replaces any tags with the corresponding functions for handling 232 | dynamic content. The compiled template can then be rendered given a context map. 233 | 234 | For example, if we wanted to render a string containing a name variable we could write the following: 235 | 236 | ```clojure 237 | (use 'selmer.parser) 238 | 239 | (render "Hello {{name}}!" {:name "Yogthos"}) 240 | =>"Hello Yogthos!" 241 | ``` 242 | 243 | To render a file we can call `render-file` instead: 244 | 245 | ```clojure 246 | (use 'selmer.parser) 247 | 248 | (render-file "home.html" {:name "Yogthos"}) 249 | ``` 250 | 251 | [**Specter**](https://github.com/nathanmarz/specter). Advanced data navigator. Specter rejects Clojure's restrictive approach to immutable data structure manipulation, instead exposing an elegant API to allow any sort of manipulation imaginable. Specter especially excels at querying and transforming nested and recursive data, important use cases that are very complex to handle with vanilla Clojure. 252 | 253 | ```clojure 254 | (def data {:a [{:aa 1 :bb 2} 255 | {:cc 3}] 256 | :b [{:dd 4}]}) 257 | 258 | ;; Manual Clojure 259 | (defn map-vals [m afn] 260 | (->> m (map (fn [[k v]] [k (afn v)])) (into (empty m)))) 261 | 262 | (map-vals data 263 | (fn [v] 264 | (mapv 265 | (fn [m] 266 | (map-vals 267 | m 268 | (fn [v] (if (even? v) (inc v) v)))) 269 | v))) 270 | 271 | ;; Specter 272 | (transform [MAP-VALS ALL MAP-VALS even?] inc data) 273 | ``` 274 | 275 | -------------------------------------------------------------------------------- /languages/COMMON_LISP.md: -------------------------------------------------------------------------------- 1 | ## Common Lisp 2 | 3 | [**Woo**](https://github.com/fukamachi/woo) is a fast non-blocking HTTP server built on top of libev. Although Woo is written in Common Lisp, it aims to be the fastest web server written in any programming language. 4 | 5 |
6 | 7 | [**Clack**](https://github.com/fukamachi/clack) is a web application environment for Common Lisp inspired by Python’s WSGI and Ruby’s Rack. 8 | 9 | Example: 10 | ```common-lisp 11 | (defvar *handler* 12 | (clack:clackup 13 | (lambda (env) 14 | (declare (ignore env)) 15 | '(200 (:content-type "text/plain") ("Hello, Clack!"))))) 16 | ``` 17 | -------------------------------------------------------------------------------- /languages/CRYSTAL.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**Amber**](https://github.com/amberframework/amber) - a web application framework written in Crystal inspired by Kemal, Rails, Phoenix and other popular application frameworks 4 | 5 | ## K 6 | 7 | [**Kemal**](https://github.com/kemalcr/kemal) - Fast, Effective, Simple web framework for Crystal. 8 | 9 | ## L 10 | 11 | [**Lucky**](https://github.com/luckyframework/lucky) - a web framework that helps you work quickly, catch bugs at compile time, and deliver blazing fast responses. 12 | 13 | ## M 14 | 15 | [**Marten**](https://github.com/martenframework/marten) - A web framework that makes building web applications easy, productive, and fun. -------------------------------------------------------------------------------- /languages/CSS.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**Animate.css**](https://github.com/daneden/animate.css)  —  Animate.css is a bunch of cool, fun, and cross-browser animations for you to use in your projects. Great for emphasis, home pages, sliders, and general just-add-water-awesomeness. 4 | 5 |
6 | 7 | ## B 8 | 9 | [**Bootstrap**](https://github.com/twbs/bootstrap) - The most popular HTML, CSS, and JavaScript framework for developing responsive, mobile first projects on the web. 10 | 11 |
12 | 13 | [**Bulma**](https://github.com/jgthms/bulma)  —  Bulma is a modern CSS framework based on Flexbox. 14 | 15 |
16 | 17 | ## C 18 | 19 | [**Codrop**](https://tympanus.net/codrops/css_reference/)  —  An extensive CSS reference made by codrops. It contain with all the important properties and info to learn CSS from the basics 20 | 21 | ## F 22 | 23 | [**Foundation**](https://github.com/zurb/foundation-sites)  —  The most advanced responsive front-end framework in the world. Quickly create prototypes and production code for sites that work on any kind of device. 24 | 25 | ## M 26 | [**Materialize**](https://materializecss.com/) — A modern responsive front-end framework based on Material Design 27 | 28 | 29 | ## P 30 | 31 | [**PostCSS**](https://github.com/postcss/postcss)  —  Transforming styles with JS plugins. These plugins can lint your CSS, support variables and mixins, transpile future CSS syntax, inline images, and more. 32 | 33 |
34 | 35 | [**Pure**](https://github.com/yahoo/pure)  —  A set of small, responsive CSS modules that you can use in every web project. 36 | 37 | ## S 38 | 39 | [**Semantic UI**](https://semantic-ui.com/) — Semantic is a development framework that helps create beautiful, responsive layouts using human-friendly HTML. 40 | 41 | ## T 42 | 43 | [**Tachyons**](https://github.com/tachyons-css/tachyons)  —  Functional css for humans. Quickly build and design new UI without writing css. 44 | 45 |
46 | 47 | [**Tailwind CSS**](https://github.com/tailwindcss/tailwindcss) — A utility-first CSS framework for rapid UI development. 48 | 49 | ## U 50 | 51 | [**UIkit**](https://github.com/uikit/uikit) — A lightweight and modular front-end framework 52 | for developing fast and powerful web interfaces. 53 | -------------------------------------------------------------------------------- /languages/D.md: -------------------------------------------------------------------------------- 1 | ## T 2 | 3 | [**Tilix**](https://gnunn1.github.io/tilix-web/) is an advanced GTK3 tiling terminal emulator that follows the Gnome Human Interface Guidelines. 4 | 5 | ## V 6 | 7 | [**Vibe.d**](http://vibed.org/) is a high-performance asynchronous I/O, concurrency and web application toolkit. It already contains many supplemental features such as database support to be able to offer a complete development environment. 8 | 9 | Example of Usage: 10 | ```D 11 | import vibe.d; 12 | 13 | void userInfo(HTTPServerRequest req, HTTPServerResponse res) 14 | { 15 | auto username = req.params["user"]; 16 | render!("userinfo.dt", username)(res); 17 | } 18 | 19 | void addUser(HTTPServerRequest req, HTTPServerResponse res) 20 | { 21 | enforceHTTP("user" in req.form, HTTPStatus.badRequest, "Missing user field."); 22 | res.redirect("/users/"~req.form["user"]); 23 | } 24 | 25 | shared static this() 26 | { 27 | auto router = new URLRouter; 28 | router.get("/users/:user", &userInfo); 29 | router.post("/adduser", &addUser); 30 | router.get("*", serveStaticFiles("./public/")); 31 | 32 | // To reduce code redundancy, you can also 33 | // use method chaining: 34 | router 35 | .get("/users/:user", &userInfo) 36 | .post("/adduser", &addUser) 37 | .get("*", serveStaticFiles("./public/")); 38 | 39 | listenHTTP(new HTTPServerSettings, router); 40 | } 41 | ``` 42 | -------------------------------------------------------------------------------- /languages/DART.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**AngularDart**](https://github.com/dart-lang/angular) is a productive web application framework that powers some of Google's most critical applications. It's built on Dart and used extensively by Google AdWords, AdSense, Fiber, and many more projects. 4 | 5 | ## D 6 | 7 | [**DartPad**](https://github.com/dart-lang/dart-pad) is a free, open-source online editor to help developers learn about Dart and Flutter. You can access it at dartpad.dev. DartPad began as an online playground for the Dart language built by the Dart tools team in 2015. It compiles, analyzes, and displays the results of its users' Dart code, and can be embedded in other websites as an iframe. 8 | 9 | ## F 10 | 11 | [**Flutter**](https://github.com/flutter/flutter) is Google's SDK for crafting beautiful, fast user experiences for mobile, web and desktop from a single codebase. Flutter works with existing code, is used by developers and organizations around the world, and is free and open source. 12 | 13 | ## P 14 | 15 | [**Pub.dev**](https://github.com/dart-lang/pub-dev), the Dart package repository, written in Dart. 16 | -------------------------------------------------------------------------------- /languages/ELIXIR.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**Azimutt**](https://github.com/azimuttapp/azimutt) - Powerful database explorer, open-source and privacy-friendly 4 | 5 | ## B 6 | 7 | [**Bandit**](https://github.com/mtrudel/bandit) - a pure Elixir web server supporting HTTP1, HTTP2 and WebSockets connections. 8 | 9 |
10 | 11 | [**broadway**](https://github.com/dashbitco/broadway) Concurrent and multi-stage data ingestion and data processing with Elixir. 12 | 13 | ## C 14 | 15 | [**cachex**](https://github.com/whitfin/cachex) A powerful caching library for Elixir with support for transactions, fallbacks and expirations. 16 | 17 |
18 | 19 | [**credo**](https://github.com/rrrene/credo)  —  a static code analysis tool for the Elixir language with a focus on teaching and code consistency. 20 | 21 | ## D 22 | 23 | [**distillery**](https://github.com/bitwalker/distillery)  —  a pure Elixir implementation of release packaging functionality for the Erlang VM (BEAM). 24 | Every alchemist requires good tools, and one of the greatest tools in the alchemist’s disposal is the distillery. The purpose of the distillery is to take something and break it down to it’s component parts, reassembling it into something better, more powerful. That is exactly what this project does — it takes your Mix project and produces an Erlang/OTP release, a distilled form of your raw application’s components; a single package which can be deployed anywhere, independently of an Erlang/Elixir installation. No dependencies, no hassle. 25 | 26 | This is a pure-Elixir, dependency-free implementation of release generation for Elixir projects. It is currently a standalone package, but may be integrated into Mix at some point in the future. 27 | 28 | ## E 29 | 30 | [**Ecto**](https://github.com/elixir-ecto/ecto). A toolkit for data mapping and language integrated query. 31 | 32 | Ecto is commonly used to interact with databases, such as PostgreSQL and MySQL via `Ecto.Adapters.SQL` (source code). Ecto is also commonly used to map data from any source into Elixir structs, whether they are backed by a database or not. 33 | 34 |
35 | 36 | [**Elixir XDR**](https://github.com/kommitters/elixir_xdr) is an open data format, specified in [RFC 4506](http://tools.ietf.org/html/rfc4506.html). This library provides a way to decode and encode XDR data from Elixir. Extend with ease to other XDR types. 37 | 38 |
39 | 40 | [**ExVCR**](https://github.com/parroty/exvcr). Record and replay HTTP interactions library for elixir. It's inspired by Ruby's VCR (https://github.com/vcr/vcr), and trying to provide similar functionalities. 41 | 42 | Basics 43 | 44 | - The following HTTP libraries can be applied. 45 | - ibrowse-based libraries. 46 | - HTTPotion 47 | - hackney-based libraries. 48 | - HTTPoison 49 | - support is very limited, and tested only with sync request of HTTPoison yet. 50 | - httpc-based libraries. 51 | - erlang-oauth 52 | - tirexs 53 | - support is very limited, and tested only with :httpc.request/1 and :httpc.request/4 54 | 55 | - HTTP interactions are recorded as JSON file. 56 | - The JSON file can be recorded automatically (vcr_cassettes) or manually updated (custom_cassettes) 57 | 58 | ## F 59 | 60 | [**Faker**](https://github.com/igas/faker) is a pure Elixir library for generating fake data. 61 | 62 |
63 | 64 | [**Firezone**](https://github.com/firezone/firezone) is a remote access manager written in Elixir. 65 | * Manage remote access through an intuitive web interface and CLI utility. 66 | * Deploy on your own infrastructure to keep control of your network traffic. 67 | * Built on WireGuard® to be stable, performant, and lightweight. 68 | 69 |
70 | 71 | [**Floki**](https://github.com/philss/floki) is a simple HTML parser that enables search for nodes using CSS selectors. 72 | 73 | Take this HTML as an example: 74 | 75 | ```html 76 | 77 | 78 | 79 |
80 |

Floki

81 | Enables search using CSS selectors 82 | Github page 83 | philss 84 |
85 | Hex package 86 | 87 | 88 | ``` 89 | 90 | Here are some queries that you can perform (with return examples): 91 | 92 | ```elixir 93 | Floki.find(html, "#content") 94 | # => [{"section", [{"id", "content"}], 95 | # => [{"p", [{"class", "headline"}], ["Floki"]}, 96 | # => {"a", [{"href", "http://github.com/philss/floki"}], ["Github page"]}]}] 97 | 98 | 99 | Floki.find(html, "p.headline") 100 | # => [{"p", [{"class", "headline"}], ["Floki"]}] 101 | 102 | Floki.find(html, "p.headline") 103 | |> Floki.raw_html 104 | # =>

Floki

105 | 106 | 107 | Floki.find(html, "a") 108 | # => [{"a", [{"href", "http://github.com/philss/floki"}], ["Github page"]}, 109 | # => {"a", [{"href", "https://hex.pm/packages/floki"}], ["Hex package"]}] 110 | 111 | 112 | Floki.find(html, "a[href^=https]") 113 | # => [{"a", [{"href", "http://github.com/philss/floki"}], ["Github page"]}, 114 | # => {"a", [{"href", "https://hex.pm/packages/floki"}], ["Hex package"]}] 115 | 116 | 117 | Floki.find(html, "#content a") 118 | # => [{"a", [{"href", "http://github.com/philss/floki"}], ["Github page"]}] 119 | 120 | 121 | Floki.find(html, "[data-model=user]") 122 | # => [{"span", [{"data-model", "user"}], ["philss"]}] 123 | 124 | 125 | Floki.find(html, ".headline, a") 126 | # => [{"p", [{"class", "headline"}], ["Floki"]}, 127 | # => {"a", [{"href", "http://github.com/philss/floki"}], ["Github page"]}, 128 | # => {"a", [{"href", "https://hex.pm/packages/floki"}], ["Hex package"]}] 129 | ``` 130 | 131 | ## G 132 | 133 | [**guardian**](https://github.com/ueberauth/guardian)  —  an authentication framework for use with Elixir applications. 134 | Guardian is based on similar ideas to Warden but is re-imagined for modern systems where Elixir manages the authentication requirements. 135 | 136 | Guardian remains a functional system. It integrates with Plug, but can be used outside of it. If you’re implementing a TCP/UDP protocol directly, or want to utilize your authentication via channels, Guardian is your friend. 137 | The core currency of authentication in Guardian is JSON Web Tokens (JWT). You can use the JWT to authenticate web endpoints, channels, and TCP sockets and it can contain any authenticated assertions that the issuer wants to include. 138 | 139 | ## H 140 | 141 | [**httpoison** ](https://github.com/edgurgel/httpoison) —  yet another HTTP client for Elixir powered by hackney. 142 | 143 | ## K 144 | 145 | [**kitto** ](https://github.com/kittoframework/kitto) —  a framework to help you create dashboards, written in Elixir/React. 146 | 147 | 148 | ## P 149 | 150 | [**Phoenix**](http://www.phoenixframework.org/)  —  Productive. Reliable. Fast. A productive web framework that does not compromise speed and maintainability. 151 | 152 |
153 | 154 | [**Plausible**](https://github.com/plausible/analytics) - Simple, open-source, lightweight (< 1 KB) and privacy-friendly web analytics alternative to Google Analytics. 155 | 156 | 157 | ## Q 158 | 159 | [**Quantum**](https://github.com/quantum-elixir/quantum-core) - is a Cron-like job scheduler for Elixir. 160 | 161 | ## S 162 | 163 | [**Stellar Base**](https://github.com/kommitters/stellar_base) is an Elixir library that provides a complete set of functions to read, write, hash, and sign XDR constructs used in [stellar-core](https://github.com/stellar/stellar-core). 164 | 165 |
166 | 167 | [**Stellar SDK**](https://github.com/kommitters/stellar_sdk) enables the construction, signing and encoding of Stellar [transactions](https://developers.stellar.org/docs/glossary/transactions) and [operations](https://developers.stellar.org/docs/start/list-of-operations) in **Elixir**, as well as provides a client for interfacing with [Horizon](https://developers.stellar.org/api/introduction) server REST endpoints to retrieve ledger information, and to submit transactions. 168 | 169 | This library is aimed at developers building Elixir applications that interact with the [**Stellar network**](https://www.stellar.org/). 170 | 171 |
172 | 173 | [**Swoosh**](https://github.com/swoosh/swoosh) - Compose, deliver and test your emails easily in Elixir 174 | Swoosh comes with many adapters, including SendGrid, Mandrill, Mailgun, Postmark and SMTP. 175 | 176 | ## T 177 | 178 | [**timex** ](https://github.com/bitwalker/timex) —  a rich, comprehensive Date/Time library for Elixir projects, with full timezone support via the :tzdata package. If you need to manipulate dates, times, datetimes, timestamps, etc., then Timex is for you! It is very easy to use Timex types in place of default Erlang types, as well as Ecto types via the timex_ecto package. 179 | 180 | Here’s a few simple examples: 181 | ```elixir 182 | > use Timex 183 | > Timex.today 184 | ~D[2016-02-29] 185 | 186 | > datetime = Timex.now 187 | # Timex.now("America/Chicago") 190 | # Duration.now 193 | # 194 | 195 | > {:ok, default_str} = Timex.format(datetime, "{ISO:Extended}") 196 | {:ok, "2016-02-29T12:30:30.120+00:00"} 197 | 198 | > {:ok, relative_str} = Timex.shift(datetime, minutes: -3) |> Timex.format("{relative}", :relative) 199 | {:ok, "3 minutes ago"} 200 | 201 | > strftime_str = Timex.format!(datetime, "%FT%T%:z", :strftime) 202 | "2016-02-29T12:30:30+00:00" 203 | 204 | > Timex.parse(default_str, "{ISO:Extended}") 205 | {:ok, # Timex.parse!(strftime_str, "%FT%T%:z", :strftime) 208 | # 6 | 7 | [**elm-test**](https://github.com/elm-explorations/test) - unit and fuzz tests for your Elm code, in Elm. 8 | 9 | Here are three example tests: 10 | 11 | ```elm 12 | suite : Test 13 | suite = 14 | describe "The String module" 15 | [ describe "String.reverse" -- Nest as many descriptions as you like. 16 | [ test "has no effect on a palindrome" <| 17 | \() -> 18 | let 19 | palindrome = 20 | "hannah" 21 | in 22 | Expect.equal palindrome (String.reverse palindrome) 23 | 24 | -- Expect.equal is designed to be used in pipeline style, like this. 25 | , test "reverses a known string" <| 26 | \() -> 27 | "ABCDEFG" 28 | |> String.reverse 29 | |> Expect.equal "GFEDCBA" 30 | 31 | -- fuzz runs the test 100 times with randomly-generated inputs! 32 | , fuzz string "restores the original string if you run it again" <| 33 | \randomlyGeneratedString -> 34 | randomlyGeneratedString 35 | |> String.reverse 36 | |> String.reverse 37 | |> Expect.equal randomlyGeneratedString 38 | ] 39 | ] 40 | ``` 41 | 42 | --- 43 | 44 | [**elm-http-builder**](https://github.com/lukewestby/elm-http-builder) - chainable functions for building HTTP requests. 45 | 46 | Example: 47 | 48 | ```elm 49 | import Http 50 | import HttpBuilder 51 | import Json.Decode as Decode 52 | import Json.Encode as Encode 53 | import Url.Builder as UrlBuilder 54 | 55 | 56 | type Status a = Loading | Loaded a | Failure 57 | 58 | 59 | type alias Model = { items : Status (List String) } 60 | 61 | 62 | itemsDecoder : Decode.Decoder (List String) 63 | itemsDecoder = 64 | Decode.list Decode.string 65 | 66 | 67 | itemEncoder : String -> Encode.Value 68 | itemEncoder item = 69 | Encode.object 70 | [ ("item", Encode.string item) ] 71 | 72 | 73 | {-| addItem will send a post request to 74 | `"http://example.com/api/items?hello=world"` with the given JSON body and a 75 | custom header. It'll try to decode with `itemsDecoder`. 76 | 77 | -} 78 | addItem : String -> Cmd Msg 79 | addItem item = 80 | UrlBuilder.crossOrigin 81 | "http://example.com" 82 | [ "api", "items" ] 83 | [ UrlBuilder.string "hello" "world" ] 84 | |> HttpBuilder.post 85 | |> HttpBuilder.withHeader "X-My-Header" "Some Header Value" 86 | |> HttpBuilder.withJsonBody (itemEncoder item) 87 | |> HttpBuilder.withTimeout 10000 88 | |> HttpBuilder.withExpect (Http.expectJson GotItem itemsDecoder) 89 | |> HttpBuilder.request 90 | 91 | 92 | type Msg = GotItem (Result Http.Error (List String)) 93 | 94 | 95 | update : Msg -> Model -> ( Model, Cmd Msg ) 96 | update msg model = 97 | case msg of 98 | GotItem (Ok items) -> 99 | ( { model | items = Loaded items } 100 | , Cmd.none 101 | ) 102 | 103 | GotItem (Err err) -> 104 | ( { model | items = Failure } , Cmd.none) 105 | ``` 106 | -------------------------------------------------------------------------------- /languages/EMACS_LISP.md: -------------------------------------------------------------------------------- 1 | ## M 2 | 3 | [**Magit**](https://github.com/magit/magit) is an interface to the version control system Git, implemented as an Emacs package. Magit aspires to be a complete Git porcelain. While we cannot claim that Magit wraps and improves upon each and every Git command, it is complete enough to allow even experienced Git users to perform almost all of their daily version control tasks directly from within Emacs. While many fine Git clients exist, only Magit and Git itself deserve to be called porcelains. 4 | 5 | ## U 6 | 7 | The [**use-package**](https://github.com/jwiegley/use-package) macro allows you to isolate package configuration in your .emacs file in a way that is both performance-oriented and, well, tidy. I created it because I have over 80 packages that I use in Emacs, and things were getting difficult to manage. Yet with this utility my total load time is around 2 seconds, with no loss of functionality! 8 | -------------------------------------------------------------------------------- /languages/ERLANG.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**apns4erl**](https://github.com/inaka/apns4erl). This lib is intended to allow you to write an APNs provider for Apple Push Notificaion services (APNs) over HTTP2 in Erlang. 4 | 5 | ## B 6 | 7 | [**Binbo**](https://github.com/DOBRO/binbo)  —  a Chess representation written in pure Erlang using **Bitboards**. It is basically aimed to be used on game servers where people play chess online. 8 | 9 | It’s called `Binbo` because its ground is a **bin**ary **bo**ard containing only *zeros* and *ones* (`0` and `1`) since this is the main meaning of Bitboards as an internal chessboard representation. 10 | 11 | Binbo also uses the **Magic Bitboards** approach for a **blazing fast** move generation of sliding pieces (rook, bishop, and queen). 12 | 13 | **Note**: it’s not a chess engine but it could be a good starting point for it. It can play the role of a core (regarding move generation and validation) for multiple chess engines running on distributed Erlang nodes, since Binbo is an OTP application itself. 14 | 15 | ## C 16 | 17 | [**Cowboy**](https://github.com/ninenines/cowboy)  —  a small, fast and modern HTTP server for Erlang/OTP. I think that everyone who interested in Erlang heard about a cowboy. 18 | 19 | Cowboy aims to provide a complete HTTP stack in a small code base. It is optimized for low latency and low memory usage, in part because it uses binary strings. 20 | 21 |
22 | 23 | [**couchdb**](https://github.com/apache/couchdb)  — a document-oriented NoSQL database. 24 | 25 | ## E 26 | 27 | [**ejabberd**](https://github.com/processone/ejabberd) is a distributed, fault-tolerant technology that allows the creation of large-scale instant messaging applications. The server can reliably support thousands of simultaneous users on a single node and has been designed to provide exceptional standards of fault tolerance. As an open source technology, based on industry-standards, ejabberd can be used to build bespoke solutions very cost effectively. 28 | 29 |
30 | 31 | [**emqttd** ](https://github.com/emqtt/emqttd) — is a distributed, massively scalable, highly extensible MQTT message broker written in Erlang/OTP. EMQ is fully open source and licensed under the Apache Version 2.0. EMQ implements both MQTT V3.1 and V3.1.1 protocol specifications, and supports MQTT-SN, CoAP, WebSocket, STOMP and SockJS at the same time. The 1.0 release of the EMQ broker has scaled to 1.3 million concurrent MQTT connections on a 12 Core, 32G CentOS server. 32 | 33 | ## H 34 | 35 | [**hackney**](https://github.com/benoitc/hackney) - HTTP client library in Erlang 36 | 37 | Main features: 38 | 39 | - no message passing (except for asynchronous responses): response is 40 | directly streamed to the current process and state is kept in a `#client{}` record. 41 | - binary streams 42 | - SSL support 43 | - Keepalive handling 44 | - basic authentication 45 | - stream the response and the requests 46 | - fetch a response asynchronously 47 | - multipart support (streamed or not) 48 | - chunked encoding support 49 | - Can send files using the sendfile API 50 | - Optional socket pool 51 | - REST syntax: `hackney:Method(URL)` (where a method can be get, post, put, delete, ...) 52 | 53 | ## I 54 | 55 | [**iso8601**](https://github.com/erlsci/iso8601) - an ISO 8601 date formating and parsing library for Erlang 56 | 57 | Example: 58 | 59 | ```erlang 60 | 1> iso8601:format(now()). 61 | <<"2012-02-16T01:06:19Z">> 62 | 2> iso8601:format(calendar:universal_time()). 63 | <<"2012-02-16T01:06:48Z">> 64 | ``` 65 | 66 | ## L 67 | 68 | [**LeoFS**](https://github.com/leo-project/leofs) is a highly available, distributed, eventually consistent object/blob store. If you are searching a storage system that is able to store huge amount and various kind of files such as photo, movie, log data and so on, LeoFS is suitable for that. 69 | 70 |
71 | 72 | [**lorawan-server**](https://github.com/gotthardp/lorawan-server) - an Open-source LoRaWAN Server that integrates both the network-server and the application-server. This is useful for application providers that operate their own LoRa network, or for device and application developers. 73 | 74 | ## M 75 | 76 | [**MongooseIM**](https://github.com/esl/MongooseIM) is robust and efficient XMPP platform aimed at large installations. Specifically designed for enterprise purposes, it is fault-tolerant, can utilize resources of multiple clustered machines and easily scale in need of more capacity (by just adding a box/VM). MongooseIM can accept client sessions over vanilla XMPP, Websockets, HTTP long-polling (a.k.a. BOSH), and a REST API. 77 | 78 | The MongooseIM platform comes with server-side components and client libraries. We provide a test suite and a monitoring server. We recommand third-party, open source client libraries for XMPP and REST API. 79 | 80 | ## N 81 | 82 | [**Nebula**](https://github.com/lk-geimfari/nebula) is a small library for colored (ANSI) output in Erlang. It's can be useful when you need to create a user-friendly command-line applications. 83 | 84 | Example: 85 | ```erlang 86 | -import(nebula, [print/1]). 87 | 88 | update_something() -> 89 | %% ... 90 | %% ... 91 | print({green, "Something has been updated successfully!"}). 92 | ``` 93 | 94 | ## P 95 | 96 | [**Prometheus.erl**](https://github.com/deadtrickster/prometheus.erl) monitoring system and time series database client in Erlang. 97 | 98 |
99 | 100 | [**PropEr**](https://github.com/manopapad/proper) is a QuickCheck-inspired open-source property-based testing tool for Erlang, developed by Manolis Papadakis, Eirini Arvaniti and Kostis Sagonas. The base PropEr system was written mainly by Manolis Papadakis, and the stateful code testing subsystem by Eirini Arvaniti. Kostis Sagonas has been actively maintaining its code base since 2012. 101 | 102 | ## R 103 | 104 | [**RabbitMQ**](https://github.com/rabbitmq/rabbitmq-server) is open source message broker software (sometimes called message-oriented middleware) that implements the Advanced Message Queuing Protocol (AMQP). The RabbitMQ server is written in the Erlang programming language and is built on the Open Telecom Platform framework for clustering and failover. Client libraries to interface with the broker are available for all major programming languages. 105 | 106 |
107 | 108 | [**Ranch**](https://github.com/ninenines/ranch) is a socket acceptor pool for TCP protocols. 109 | 110 | Ranch aims to provide everything you need to accept TCP connections with a small code base and low latency while being easy to use directly as an application or to embed into your own. 111 | 112 | Ranch provides a modular design, letting you choose which transport and protocol are going to be used for a particular listener. Listeners accept and manage connections on one port, and include facilities to limit the number of concurrent connections. Connections are sorted into pools, each pool having a different configurable limit. 113 | 114 |
115 | 116 | [**riak**](https://github.com/basho/riak) is a decentralized datastore from Basho Technologies. 117 | 118 |
119 | 120 | [**rebar3**](https://github.com/erlang/rebar3) is an Erlang tool that makes it easy to create, develop, and release Erlang libraries, applications, and systems in a repeatable manner. 121 | 122 | ## S 123 | 124 | [**Sheldon**](https://github.com/inaka/sheldon) the Erlang spell checker. 125 | 126 | ## V 127 | 128 | [**VerneMQ**](https://github.com/erlio/vernemq)  —  a high-performance, distributed MQTT message broker. It scales horizontally and vertically on commodity hardware to support a high number of concurrent publishers and consumers while maintaining low latency and fault tolerance. VerneMQ is the reliable message hub for your IoT platform or smart products. 129 | 130 | ## W 131 | 132 | [**Wings3D**](https://github.com/dgud/wings)  — is an advanced sub-division 3D modeller. 133 | -------------------------------------------------------------------------------- /languages/GOLANG.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**Apache DevLake**](https://github.com/apache/incubator-devlake) — is an open-source dev data platform to ingest, analyze, and visualize the fragmented data from DevOps tools，which can distill insights to improve engineering productivity. 4 | 5 | ## B 6 | 7 | [**Blackfriday**](https://github.com/russross/blackfriday) — is a Markdown processor implemented in Go. It is paranoid about its input (so you can safely feed it user-supplied data), it is fast, it supports common extensions (tables, smart punctuation substitutions, etc.), and it is safe for all utf-8 (unicode) input. 8 | 9 | HTML output is currently supported, along with Smartypants extensions. An experimental LaTeX output engine is also included. 10 | 11 | ## C 12 | 13 | [**Caddy**](https://github.com/mholt/caddy) — a general-purpose web server for Windows, Mac, Linux, BSD, and Android. It is a capable but easier alternative to other popular web servers. 14 | 15 |
16 | 17 | [**Cayley**](https://github.com/cayleygraph/cayley) — is an open-source graph inspired by the graph database behind Freebase and Google’s Knowledge Graph. 18 | 19 | Its goal is to be a part of the developer’s toolbox where Linked Data and graph-shaped data (semantic webs, social networks, etc) in general are concerned. 20 | 21 |
22 | 23 | [**chi**](https://github.com/pressly/chi) — is a lightweight, idiomatic and composable router for building Go 1.7+ HTTP services. It's especially good at helping you write large REST API services that are kept maintainable as your project grows and changes. chi is built on the new context package introduced in Go 1.7 to handle signaling, cancelation and request-scoped values across a handler chain. 24 | 25 | The focus of the project has been to seek out an elegant and comfortable design for writing REST API servers, written during the development of the Pressly API service that powers our public API service, which in turn powers all of our client-side applications. 26 | 27 | The key considerations of chi's design are: project structure, maintainability, standard http handlers (stdlib-only), developer productivity, and deconstructing a large system into many small parts. The core router github.com/pressly/chi is quite small (less than 1000 LOC), but we've also included some useful/optional subpackages: middleware, render and docgen. We hope you enjoy it too! 28 | 29 |
30 | 31 | [**cobra**](https://github.com/spf13/cobra) — a library for creating powerful modern CLI applications as well as a program to generate applications and command files. 32 | 33 |
34 | 35 | [**Convox Rack**](https://github.com/convox/rack) — is open source PaaS built on top of expert infrastructure automation and devops best practices. 36 | 37 | Rack gives you a simple developer-focused API that lets you build, deploy, scale and manage apps on private infrastructure with ease. 38 | 39 |
40 | 41 | [**Croc**](https://github.com/schollz/croc) - is a tool that allows any two computers to simply and securely transfer files and folders. AFAIK, croc is the only CLI file-transfer tool that does all of the following: 42 | 43 | * allows any two computers to transfer data (using a relay) 44 | * provides end-to-end encryption (using PAKE) 45 | * enables easy cross-platform transfers (Windows, Linux, Mac) 46 | * allows multiple file transfers 47 | * allows resuming transfers that are interrupted 48 | * local server or port-forwarding not needed 49 | * ipv6-first with ipv4 fallback 50 | 51 | ## D 52 | 53 | [**Distribution**](https://github.com/docker/distribution) — The Docker toolset to pack, ship, store, and deliver content. 54 | 55 |
56 | 57 | [**Docker**](https://github.com/docker/docker) — is an open source project to pack, ship and run any application as a lightweight container. 58 | 59 |
60 | 61 | [**dry**](https://github.com/moncho/dry) — a terminal application to manage Docker containers and images. It aims to be an alternative to the official Docker CLI when it is needed to repeatedly execute commands on existing containers and images, and also as a tool to monitor Docker containers from a terminal. 62 | 63 | ## E 64 | 65 | [**ESBuild**](https://github.com/evanw/esbuild) — is an extremely fast JavaScript and CSS bundler and minifier, built in Golang 66 | 67 | ## F 68 | 69 | [**fasthttp**](https://github.com/valyala/fasthttp) — is a fast HTTP implementation for Go. 70 | 71 |
72 | 73 | [**Fiber**](https://github.com/gofiber/fiber) — is an [Express](https://github.com/expressjs/express) inspired web framework built on top of [Fasthttp](https://github.com/valyala/fasthttp), the fastest HTTP engine for [Go](https://golang.org/doc/). Designed to ease things up for fast development with zero memory allocation and performance in mind. 74 | 75 | Quickstart example: 76 | ```go 77 | package main 78 | 79 | import "github.com/gofiber/fiber/v2" 80 | 81 | func main() { 82 | app := fiber.New() 83 | 84 | app.Get("/", func(c *fiber.Ctx) error { 85 | return c.SendString("Hello, World 👋!") 86 | }) 87 | 88 | app.Listen(":3000") 89 | } 90 | ``` 91 | 92 |
93 | 94 | [**frp**](https://github.com/fatedier/frp) - A fast reverse proxy to help you expose a local server behind a NAT or firewall to the internet. 95 | 96 | * Expose any http and https service behind a NAT or firewall to the internet by a server with public IP address(Name-based Virtual Host Support). 97 | * Expose any tcp or udp service behind a NAT or firewall to the internet by a server with public IP address. 98 | 99 | [**fzf**](https://github.com/junegunn/fzf) — is a general-purpose command-line fuzzy finder. 100 | 101 | ## G 102 | 103 | 104 | [**Gin**](https://github.com/gin-gonic/gin) — is a web framework written in Go. It features a martini-like API with much better performance, up to 40 times faster thanks to httprouter. If you need performance and good productivity, you will love Gin. 105 | 106 |
107 | 108 | [**Gitql**](https://github.com/cloudson/gitql) — is a Git query language. 109 | 110 |
111 | 112 | [**Gizmo**](https://github.com/NYTimes/gizmo). Microservice Toolkit 113 | This toolkit provides packages to put together server and pubsub daemons with the following features: 114 | 115 | * standardized configuration and logging 116 | * health check endpoints with configurable strategies 117 | * configuration for managing pprof endpoints and log levels 118 | * structured logging containing basic request information 119 | * useful metrics for endpoints 120 | * graceful shutdowns 121 | * basic interfaces to define our expectations and vocabulary 122 | 123 |
124 | 125 | [**gobot**](https://github.com/hybridgroup/gobot) — a framework using the Go programming language for robotics, physical computing, and the Internet of Things. 126 | 127 |
128 | 129 | [**gogs**](https://github.com/gogits/gogs) — Gogs (Go Git Service) is a painless self-hosted Git service. 130 | 131 |
132 | 133 | [**GoReplay**](https://github.com/buger/goreplay) — is the simplest and safest way to test your app using real traffic before you put it into production. 134 | 135 | As your application grows, the effort required to test it also grows exponentially. GoReplay offers you the simple idea of reusing your existing traffic for testing, which makes it incredibly powerful. Our state of art technique allows to analyze and record your application traffic without affecting it. This eliminates the risks that come with putting a third party component in the critical path. 136 | 137 |
138 | 139 | [**go-callvis**](https://github.com/TrueFurby/go-callvis) — a development tool to help visualize call graph of your Go program using Graphviz's dot format. 140 | 141 | Purpose of this tool is to provide a visual overview of your program by using the data from call graph and its relations with packages and types. This is especially useful in larger projects where the complexity of the code rises or when you are just simply trying to understand code structure of somebody else. 142 | 143 | ## H 144 | 145 | [**Helm**](https://github.com/helm/helm) is a tool that streamlines installing and managing Kubernetes applications. Think of it like apt/yum/homebrew for Kubernetes. 146 | 147 | Use Helm to: 148 | - Find and use popular software packaged as Helm Charts to run in Kubernetes 149 | - Share your own applications as Helm Charts 150 | - Create reproducible builds of your Kubernetes applications 151 | - Intelligently manage your Kubernetes manifest files 152 | - Manage releases of Helm packages 153 | 154 |
155 | 156 | [**Hugo**](https://github.com/spf13/hugo) — a static HTML and CSS website generator written in Go. It is optimized for speed, easy use and configurability. Hugo takes a directory with content and templates and renders them into a full HTML website. 157 | 158 | ## I 159 | 160 | [**InfluxDB**](https://github.com/influxdata/influxdb) — is an open source time series database with no external dependencies. It's useful for recording metrics, events, and performing analytics. 161 | 162 | Features 163 | 164 | * Built-in [HTTP API](https://docs.influxdata.com/influxdb/latest/guides/writing_data/) so you don't have to write any server side code to get up and running. 165 | * Data can be tagged, allowing very flexible querying. 166 | * SQL-like query language. 167 | * Simple to install and manage, and fast to get data in and out. 168 | * It aims to answer queries in real-time. That means every data point is 169 | indexed as it comes in and is immediately available in queries that 170 | should return in < 100ms. 171 | 172 | [**Ion**](https://github.com/pion/ion) is a distributed real-time communication system, the goal is to chat anydevice, anytime, anywhere! 173 | 174 |
175 | 176 | [**IPFS**](https://github.com/ipfs/ipfs) (the InterPlanetary File System) is a new hypermedia distribution protocol, addressed by content and identities. IPFS enables the creation of completely distributed applications. It aims to make the web faster, safer, and more open. 177 | 178 | IPFS is a distributed file system that seeks to connect all computing devices with the same system of files. In some ways, this is similar to the original aims of the Web, but IPFS is actually more similar to a single bittorrent swarm exchanging git objects. You can read more about its origins in the paper IPFS - Content Addressed, Versioned, P2P File System. 179 | 180 | IPFS is becoming a new major subsystem of the internet. If built right, it could complement or replace HTTP. It could complement or replace even more. It sounds crazy. It is crazy. 181 | 182 | ## K 183 | 184 | [**Kubernetes**](https://kubernetes.io) — is an open source system for managing containerized applications across multiple hosts, providing basic mechanisms for deployment, maintenance, and scaling of applications. Kubernetes is hosted by the Cloud Native Computing Foundation. 185 | 186 | Kubernetes builds upon a decade and a half of experience at Google running production workloads at scale using a system called Borg, combined with best-of-breed ideas and practices from the community. 187 | 188 |
189 | 190 | [**kube-green**](https://kube-green.dev/) - kube-green is a simple k8s addon that automatically shuts down (some of) your resources when you don't need them. 191 | 192 | How many of your dev/preview pods stay on during weekends? Or at night? It's a waste of resources! And money! But fear not, kube-green is here to the rescue. 193 | 194 | ## L 195 | 196 | [**logrus**](https://github.com/Sirupsen/logrus) — a structured logger for Golang, completely API compatible with the standard library logger. 197 | 198 | ## N 199 | 200 | [**Nanobox**](https://nanobox.io) — is a cross-platform micro-PaaS (μPaaS) that allows developers to focus on application development, rather than the complexities of infrastructure configuration and management. 201 | 202 | Nanobox creates isolated development environments (using Docker) which are staged locally, and deployed anywhere. This guarantees parity of application environments across entire teams throughout the development lifecycle (dev, staging, production, etc.). 203 | 204 |
205 | 206 | [**Nanopack**](http://nanopack.io/) is a collection of libraries aimed at improving infrastructure development and management through a fundamentally different approach to building infrastructure components and services. 207 | 208 | Libraries include: 209 | 210 | * [Yoke](https://github.com/nanopack/yoke) - Postgres high-availability cluster with auto-failover and automated cluster recovery. 211 | * [Redundis](https://github.com/nanopack/redundis) - Redis high-availability cluster using Sentinel to transparently proxy connections to the active primary member. 212 | * [Portal](https://github.com/nanopack/portal) - An api-driven, in-kernel layer 2/3 load balancer. 213 | * [Logvac](https://github.com/nanopack/logvac) - Simple, lightweight, api-driven log aggregation service with realtime push capabilities and historical persistence. 214 | * [Hoarder](https://github.com/nanopack/hoarder) - A simple, api-driven storage system for storing code builds and cached libraries for cloud-based deployment services. 215 | * [Shaman](https://github.com/nanopack/shaman) - Small, lightweight, api-driven dns server. 216 | * [Mist](https://github.com/nanopack/mist) - A distributed, tag-based pub-sub service for modern web applications and container-driven cloud. 217 | * [more...](https://github.com/nanopack) 218 | 219 |
220 | 221 | [**Negroni**](https://github.com/urfave/negroni). Idiomatic HTTP Middleware for Golang 222 | 223 | Example: 224 | ```golang 225 | package main 226 | 227 | import ( 228 | "fmt" 229 | "net/http" 230 | 231 | "github.com/urfave/negroni" 232 | ) 233 | 234 | func main() { 235 | mux := http.NewServeMux() 236 | mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) { 237 | fmt.Fprintf(w, "Welcome to the home page!") 238 | }) 239 | 240 | n := negroni.Classic() // Includes some default middlewares 241 | n.UseHandler(mux) 242 | 243 | http.ListenAndServe(":3000", n) 244 | } 245 | ``` 246 | 247 |
248 | 249 | [**NSQ**](https://github.com/nsqio/nsq) — is a realtime distributed messaging platform designed to operate at scale, handling billions of messages per day. 250 | 251 | It promotes distributed and decentralized topologies without single points of failure, enabling fault tolerance and high availability coupled with a reliable message delivery guarantee. See features & guarantees. 252 | 253 | Operationally, NSQ is easy to configure and deploy (all parameters are specified on the command line and compiled binaries have no runtime dependencies). For maximum flexibility, it is agnostic to data format (messages can be JSON, MsgPack, Protocol Buffers, or anything else). Official Go and Python libraries are available out of the box (as well as many other client libraries) and, if you're interested in building your own, there's a protocol spec. 254 | 255 | ## P 256 | 257 | [**Packer**](https://github.com/mitchellh/packer) — is a tool for building identical machine images for multiple platforms 258 | from a single source configuration. 259 | 260 | Packer is lightweight, runs on every major operating system, and is highly 261 | performant, creating machine images for multiple platforms in parallel. Packer 262 | comes out of the box with support for the following platforms: 263 | 264 | * Amazon EC2 (AMI). Both EBS-backed and instance-store AMIs 265 | * Azure 266 | * DigitalOcean 267 | * Docker 268 | * Google Compute Engine 269 | * OpenStack 270 | * Parallels 271 | * QEMU. Both KVM and Xen images. 272 | * VirtualBox 273 | * VMware 274 | 275 | Support for other platforms can be added via plugins. 276 | 277 |
278 | 279 | [**pgweb**](https://github.com/sosedoff/pgweb) — Web-based PostgreSQL database browser written in Go. 280 | 281 | ## T 282 | 283 | [**Terraform**](https://github.com/hashicorp/terraform) — is a tool for building, changing, and versioning infrastructure safely and efficiently. Terraform can manage existing and popular service providers as well as custom in-house solutions. 284 | 285 |
286 | 287 | [**testify**](https://github.com/stretchr/testify) — a sacred extension to the standard go testing package. 288 | 289 | Example: 290 | ```golang 291 | package yours 292 | 293 | import ( 294 | "testing" 295 | "github.com/stretchr/testify/assert" 296 | ) 297 | 298 | func TestSomething(t *testing.T) { 299 | 300 | // assert equality 301 | assert.Equal(t, 123, 123, "they should be equal") 302 | 303 | // assert inequality 304 | assert.NotEqual(t, 123, 456, "they should not be equal") 305 | 306 | // assert for nil (good for errors) 307 | assert.Nil(t, object) 308 | 309 | // assert for not nil (good when you expect something) 310 | if assert.NotNil(t, object) { 311 | 312 | // now we know that object isn't nil, we are safe to make 313 | // further assertions without causing any errors 314 | assert.Equal(t, "Something", object.Value) 315 | 316 | } 317 | 318 | } 319 | ``` 320 | 321 |
322 | 323 | [**tile38**](https://github.com/tidwall/tile38) — an open source, in-memory geolocation data store, spatial index, and realtime geofence. It supports a variety of object types including lat/lon points, bounding boxes, XYZ tiles, Geohashes, and GeoJSON. 324 | 325 |
326 | 327 | [**traefik**](https://github.com/containous/traefik) — a modern HTTP reverse proxy and load balancer made to deploy microservices with ease. It supports several backends (Docker, Swarm, Kubernetes, Marathon, Mesos, Consul, Etcd, Zookeeper, BoltDB, Eureka, Rest API, file…) to manage its configuration automatically and dynamically. 328 | 329 |
330 | 331 | [**Tyk**](https://github.com/TykTechnologies/tyk) — is an open source, fast and scalable API management platform featuring an API gateway, API analytics, developer portal and API management dashboard. 332 | -------------------------------------------------------------------------------- /languages/HASKELL.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**Accelerate**](https://www.acceleratehs.org/) is a general-purpose library which aims to provide high performance parallel array computations in Haskell. It allows creating large high performance computing tasks that can execute on a variety of CPUs and GPUs as well as hardware accelerators. 4 | 5 | ## D 6 | 7 | [**Diagrams**](https://diagrams.github.io/) is a Haskell library to create declarative graphics. It is a powerful, flexible, domain specific language which allows describing graphics in terms of their elements (e.g., squares, circles, lines) and their positions (absolute or relative to each other). Output can be a raster image (e.g., BMP) or a vector image or just a canvas in other GUI applications. 8 | 9 | ## G 10 | 11 | [**Gifcurry**](https://github.com/lettier/gifcurry) is the open-source, Haskell-built video editor for GIF makers. Load a video, make some edits, and save it as a GIF—Gifcurry makes your life easy! Most video formats should work, so go wild. And since it's made with Haskell, you know it's good. 12 | 13 |
14 | 15 | [**Glance**](https://github.com/rgleichman/glance) is a visual syntax for the programming language Haskell. The goal of this project is to increase programmer happiness and productivity by allowing programmers to create and understand programs in new and different ways. Currently, the Glance executable produces a visual representation of your code in the form of an SVG image when given a textual Haskell source file. In the future, I hope to create a visual editor for Haskell. Please scroll down to see some example images. 16 | 17 | ## H 18 | 19 | [**Hakyll**](https://jaspervdj.be/hakyll/) is a static website generator written in Haskell. The compiler transforms files in various formats into HTML files which can then be served by a web server. The project offers a starter template but is also highly configurable. Multiple CSS themes are available. 20 | 21 |
22 | 23 | [**hadolint**](https://github.com/lukasmartinelli/hadolint)  —  a smarter Dockerfile linter that helps you build best practice Docker images. The linter is parsing the Dockerfile into an AST and performs rules on top of the AST. hadolint written in Haskell. 24 | 25 | 26 |
27 | 28 | [**hledger**](https://hledger.org/) is a Haskell library for plain-text accounting. It allows keeping track of one's personal finances as well as supporting situations with large number of accounts that need to be tracked. It supports importing data from multiple formats. The project also showcases multiple GUI editors and a web interface. 29 | 30 |
31 | 32 | [**http-client**](https://github.com/snoyberg/http-client) is a mega-repo for housing the http-client family of packages for Haskell. These packages provide a low level HTTP client engine (http-client), different backends for providing SSL support (http-client-tls and http-client-openssl), and higher-level APIs for user convenience (http-conduit). 33 | 34 | ## P 35 | 36 | [**Pandoc**](https://github.com/jgm/pandoc) is a Haskell library for converting from one markup format to another, and a command-line tool that uses this library. It can read Markdown, CommonMark, PHP Markdown Extra, GitHub-Flavored Markdown, MultiMarkdown, and (subsets of) Textile, reStructuredText, HTML, LaTeX, MediaWiki markup, TWiki markup, Haddock markup, OPML, Emacs Org mode, DocBook, txt2tags, EPUB, ODT and Word docx; and it can write plain text, Markdown, CommonMark, PHP Markdown Extra,GitHub-Flavored Markdown, MultiMarkdown, reStructuredText, XHTML, HTML5, LaTeX (including beamer slide shows), ConTeXt, RTF, OPML, DocBook, OpenDocument, ODT, Word docx, GNU Texinfo, MediaWiki markup, DokuWiki markup, ZimWiki markup, Haddock markup, EPUB (v2 or v3), FictionBook2, Textile, groff man pages, Emacs Org mode, AsciiDoc, InDesign ICML, TEI Simple, and Slidy, Slideous, DZSlides, reveal.js or S5 HTML slide shows. It can also produce PDF output on systems where LaTeX, ConTeXt, or wkhtmltopdf is installed. 37 | 38 |
39 | 40 | [**postgrest**](https://github.com/begriffs/postgrest)  —  PostgREST serves a fully RESTful API from any existing PostgreSQL database. It provides a cleaner, more standards-compliant, faster API than you are likely to write from scratch. PostgREST written in Haskell. 41 | 42 | ## S 43 | 44 | [**Stack**](https://github.com/commercialhaskell/stack) is a cross-platform program for developing Haskell projects. It is intended for Haskellers both new and experienced. 45 | 46 |
47 | 48 | [**Stan**](https://kowainik.github.io/projects/stan) is a static analyzer for Haskell programs. It reports common programming errors and suggest coding style improvements as well as changes that would make the project be more resilient, secure and bug free. 49 | 50 | ## T 51 | 52 | [**TaskLite**](https://tasklite.org/introduction.html) is a CLI-based task tracking application, similar to TaskWarrior but with a focus on performance and prevention of bugs that would result in data loss. It is built using Haskell and SQLite. 53 | 54 |
55 | 56 | [**Termonad**](https://github.com/cdepillabout/termonad) is a full featured terminal emulator written in Haskell. It can be used as a replacement to iTerm2, Gnome Terminal, KTerm and many other terminal emulators. 57 | 58 | ## U 59 | 60 | [**Unison**](https://www.unisonweb.org/) is a programming language built for the elastic distributed computation future. All functions and code is immutable and referenced via its content. The Unison compiler is written in Haskell. 61 | 62 | ## X 63 | 64 | [**XMonad**](https://github.com/xmonad/xmonad) is a dynamically tiled window manager which is fully configurable in Haskell. It automates windows positioning, reducing time spent aligning new windows and searching for them. 65 | 66 | ## Y 67 | 68 | [**Yesod**](https://github.com/yesodweb/yesod)  —  an advanced RESTful web framework using the Haskell programming language. 69 | -------------------------------------------------------------------------------- /languages/HAXE.md: -------------------------------------------------------------------------------- 1 | ## H 2 | [**HaxePunk**](https://github.com/HaxePunk/HaxePunk) is a powerful cross-platform 2D game engine, based on the FlashPunk AS3 library. 3 | 4 | * Builds for HTML5 (WebGL), Windows, Mac, Linux, iOS, and Android 5 | * Hardware acceleration and texture atlas support 6 | * Gamepad and multi-touch input 7 | 8 |
9 | 10 | [**Heaps**](https://github.com/HeapsIO/heaps) is a cross platform graphics engine designed for high performance games. It's designed to leverage modern GPUs that are commonly available on desktop, mobile and consoles. 11 | 12 |
13 | 14 | [**Haxe CheckStyle Documentation**](https://haxecheckstyle.github.io/docs/haxe-checkstyle/home.html) - Haxe Checkstyle is a static analysis tool to help developers write Haxe code that adheres to a coding standard. Not only improve readability, but also allows other team members to better understand each other’s code. Ideal for any project that wants to enforce coding conventions. 15 | 16 |
17 | 18 | [**HaxeFoundation**](https://github.com/HaxeFoundation/haxe) - Active repository and websites that offer examples, usage and guidances for using Hexe. Whole the Cross-Platform Toolkit 19 | 20 |
21 | 22 | [**HXElectron**](https://github.com/tong/hxelectron) - Haxe type definitions for electron, a framework for building cross-platform desktop applications with JavaScript, HTML, and CSS. 23 | 24 | ## I 25 | 26 | [**Iron**](https://github.com/armory3d/iron) is a 3D engine core library built with Kha and Haxe. Powering Armory. 27 | 28 | ## K 29 | [**Kha**](https://github.com/Kode/Kha) is a low level sdk for building games and media applications in a portable way. 30 | Think SDL, but super-charged. Based on the Haxe programming language and the krafix shader-compiler it can cross-compile your code and 31 | optimize your assets for even the most obscure systems. Kha is so portable, it can in fact run on top of other game engines and its 32 | generational graphics and audio api design gets the best out of every target, supporting super fast 2D graphics just as well as high 33 | end 3D graphics. Also, Kha probably added a new target while you were reading this text. 34 | -------------------------------------------------------------------------------- /languages/JAVA.md: -------------------------------------------------------------------------------- 1 | ## D 2 | 3 | [**Druid**](https://github.com/druid-io/druid) is a distributed, column-oriented, real-time analytics data store that is commonly used to power exploratory dashboards in multi-tenant environments. 4 | 5 | Druid excels as a data warehousing solution for fast aggregate queries on petabyte sized data sets. Druid supports a variety of flexible filters, exact calculations, approximate algorithms, and other useful calculations. 6 | 7 | Druid can load both streaming and batch data and integrates with Samza, Kafka, Storm, Spark, and Hadoop. 8 | 9 |
10 | 11 | [**Dbeaver**](https://github.com/dbeaver/dbeaver) is a Free multi-platform database tool for developers, SQL programmers, database administrators and analysts. Supports any database which has JDBC driver (which basically means - ANY database). EE version also supports non-JDBC datasources (WMI, MongoDB, Cassandra, Redis). 12 | 13 | Has a lot of features including metadata editor, SQL editor, rich data editor, ERD, data export/import/migration, SQL execution plans, etc. 14 | Based on Eclipse platform. 15 | 16 | Uses plugins architecture and provides additional functionality for the following databases: MySQL/MariaDB, PostgreSQL, Greenplum, Oracle, DB2 LUW, Exasol, SQL Server, Sybase/SAP ASE, SQLite, Firebird, H2, HSQLDB, Derby, Teradata, Vertica, Netezza, Informix, etc. 17 | 18 | The project's site: http://dbeaver.io 19 | 20 | ## E 21 | 22 | [**Encon**](https://github.com/appulse-projects/encon-java) - is a Java library, **E**rlang **N**ode **CON**nector, which allows your `JVM` app to duplex interact with `Erlang` or `Elixir` nodes. It is based on [Erlang Distribution Protocol](http://erlang.org/doc/apps/erts/erl_dist_protocol.html) and provides a convenient way to work with its components. The project consists of different sub-modules, start from basic elements like Erlang term serialization/deserialization, continue to Erlang distribution protocol itself and end with data mapping and Spring integration. 23 | 24 | The project's site: https://appulse.io 25 | 26 | ## J 27 | 28 | [**JPA**](https://github.com/spring-projects/spring-data-jpa) - is a Java library. **J**ava **P**ersistence **A**PI ensures the management of persistence and object/relational mapping. These are helpful while using the JPA in the development of applications using the platform for Java EE 5. It provides O-R mapping facility to manage relational data in java application. 29 | 30 | ### JPA areas: 31 | 32 | - Java Persistence API 33 | - O-R mapping metadata 34 | - The query language 35 | 36 |
37 | 38 | [**Jolly day**](https://github.com/svendiedrichsen/jollyday) - is a Java library. This project solve the holiday 'problem'. The idea behind this is to have an independent API which can be used in any kind of environment. That means no network or database needed. 39 | 40 | There are two release branches which are based on different Java versions. 41 | 42 | - 0.4.x - Java 7 - uses JODA time API 43 | - 0.5.x - Java 8 44 | 45 | [**JUnit 5**](https://github.com/junit-team/junit5/) - is a Java library. JUnit 5 is the next generation of JUnit. The goal is to create an up-to-date foundation for developer-side testing on the JVM. This includes focusing on Java 8 and above, as well as enabling many different styles of testing. 46 | JUnit 5 is the result of JUnit Lambda and its crowdfunding campaign on Indiegogo. 47 | 48 | ## L 49 | 50 | [**libGDX**](https://github.com/libgdx/libgdx) is a cross-platform Java game development framework based on OpenGL (ES) that works on Windows, Linux, Mac OS X, Android, your WebGL enabled browser and iOS. 51 | 52 |
53 | 54 | [**Lombok**](https://github.com/rzwitserloot/lombok) Project **Lombok** is a java library that automatically plugs into your editor and build tools, spicing up your java. 55 | Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more. 56 | 57 | ## M 58 | 59 | [**Mockito**](https://github.com/mockito/mockito) is 60 | is an open source testing framework for Java released under the MIT License. The framework allows the creation of test double objects in automated unit tests for the purpose of test-driven development or behavior-driven development. The framework's name and logo are a play on mojitos, a type of drink. 61 | 62 | ## S 63 | 64 | [**Spring Boot**](https://github.com/spring-projects/spring-boot) makes it easy to create Spring-powered, production-grade applications and services with absolute minimum fuss. It takes an opinionated view of the Spring platform so that new and existing users can quickly get to the bits they need. You can use Spring Boot to create stand-alone Java applications that can be started using java -jar or more traditional WAR deployments. We also provide a command line tool that runs spring scripts. 65 | 66 | [**SpringFox**](https://github.com/springfox/springfox) Automated JSON API documentation for API's built with Spring 67 | 68 | ## T 69 | 70 | [**trino**](https://github.com/trinodb/trino) — is a fast distributed SQL query engine for big data analytics. 71 | 72 | Trino, the distributed SQL query engine for big data, formerly known as PrestoSQL 73 | -------------------------------------------------------------------------------- /languages/JAVASCRIPT.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**A-Frame**](https://github.com/aframevr/aframe) is a web framework for building virtual reality (VR) experiences. A-Frame scenes are built with HTML and an entity-component architecture, that work across mobile, desktop, Vive, and Rift. 4 | 5 |
6 | 7 | [**Ace**](https://github.com/ajaxorg/ace)  —  Ace is a standalone code editor written in JavaScript. 8 | 9 | Ace's goal is to create a browser based editor that matches and extends the features, usability and performance of existing native editors such as TextMate, Vim or Eclipse. It can be easily embedded in any web page or JavaScript application. Ace is developed as the primary editor for Cloud9 IDE and the successor of the Mozilla Skywriter (Bespin) Project. 10 | 11 |
12 | 13 | [**async**](https://github.com/caolan/async)  —  a utility module which provides straight-forward, powerful functions for working with asynchronous JavaScript. Although originally designed for use with Node.js and installable via npm install --save async, it can also be used directly in the browser. 14 | 15 |
16 | 17 | [**AVA**](https://github.com/avajs/ava) is Futuristic JavaScript test runner. Ava takes advantage of JavaScript asynchronism to runs your tests concurrently, which is especially beneficial for IO heavy tests. AVA has simple test syntax and enforces atomic tests. 18 | 19 | ## B 20 | 21 | [**babel**](https://github.com/babel/babel)  — :tropical_fish: Babel is a compiler for writing next generation JavaScript. 22 | 23 | ## B 24 | 25 | [**BabylonJS**](https://github.com/BabylonJS) a powerful, beautiful, simple, and open game and rendering engine packed into a friendly JavaScript framework. 26 | 27 |
28 | 29 | [**btw**](https://github.com/btw-so/btw) btw is an open source personal website builder. 30 | 31 | ## C 32 | 33 | [**Chart.js**](https://github.com/chartjs/Chart.js)  —  a simple HTML5 Charts using the canvas element. 34 | 35 | Chart.js provides two different builds that are available for your use. The Chart.js and Chart.min.js files include Chart.js and the accompanying color parsing library. If this version is used and you require the use of the time axis, Moment.js will need to be included before Chart.js. 36 | 37 |
38 | 39 | [**Countly**](https://github.com/countly/countly-server)  — A plugin-based, real-time mobile, web and desktop analytics platform with more than 10 different SDKs. Countly also includes an extensive push notifications and crash reporting service for mobile devices. 40 | 41 | ## D 42 | 43 | [**D3**](https://github.com/d3/d3)  —  a JavaScript library for visualizing data using web standards. D3 helps you bring data to life using SVG, Canvas and HTML. D3 combines powerful visualization and interaction techniques with a data-driven approach to DOM manipulation, giving you the full capabilities of modern browsers and the freedom to design the right visual interface for your data. 44 | 45 |
46 | 47 | [**date-fns**](https://github.com/date-fns/date-fns) — :hourglass: Modern JavaScript date utility library :hourglass:. 48 | 49 | date-fns provides the most comprehensive, yet simple and consistent toolset for manipulating JavaScript dates in a **Browser** & **Node.js**. 50 | 51 | 52 |
53 | 54 | [**Docsify**](https://github.com/QingWei-Li/docsify)  —  :black_joker: A magical documentation site generator. 55 | 56 | ## E 57 | [**Enzyme**](https://github.com/airbnb/enzyme) is a JavaScript Testing utility for React that makes it easier to assert, manipulate, and traverse your React Components’ output. 58 | 59 | Enzyme’s API is meant to be intuitive and flexible by mimicking jQuery’s API for DOM manipulation and traversal. 60 | 61 | Enzyme is unopinionated regarding which test runner or assertion library you use, and should be compatible with all major test runners and assertion libraries out there. The documentation and examples for enzyme use mocha and chai, but you should be able to extrapolate to your framework of choice. 62 | 63 |
64 | 65 | [**Express**](https://github.com/expressjs/express)  — Fast, unopinionated, minimalist web framework for node. 66 | 67 |
68 | 69 | [**Exifr**](https://github.com/MikeKovarik/exifr) — The fastest and most versatile JS EXIF reading library. 70 | 71 | ## F 72 | 73 | [**Fabric.js**](https://github.com/kangax/fabric.js) is a framework that makes it easy to work with HTML5 canvas element. It is an interactive object model on top of canvas element. It is also an SVG-to-canvas parser. 74 | 75 |
76 | 77 | [**filepond**](https://github.com/pqina/filepond) — is library that can upload anything you throw at it, optimizes images for faster uploads, and offers a great, accessible, silky smooth user experience. 78 | 79 |
80 | 81 | [**fullPage.js**](https://github.com/alvarotrigo/fullPage.js) — a simple and easy to use plugin to create fullscreen scrolling websites (also known as single page websites or onepage sites). It allows the creation of fullscreen scrolling websites, as well as adding some landscape sliders inside the sections of the site. 82 | 83 | ## G 84 | 85 | [**Gatsby**](https://github.com/gatsbyjs/gatsby) — ⚛️📄🚀 Blazing-fast site generator for React 86 | 87 | Gatsby is a blazing-fast static site generator for React. Powered By GraphQL and super extensive. 88 | 89 |
90 | 91 | [**Ghost**](https://github.com/TryGhost/Ghost)  — A simple, powerful publishing platform. 92 | 93 |
94 | 95 | [**Gulp**](https://github.com/gulpjs/gulp)  — The streaming build system. 96 | 97 | ## H 98 | 99 | [**Hexo**](https://github.com/hexojs/hexo)  —  A fast, simple & powerful blog framework, powered by Node.js. 100 | 101 |
102 | 103 | [**Hyper**](https://github.com/zeit/hyper)  —  A terminal built on web technologies. 104 | 105 |
106 | 107 | [**Highcharts**](https://github.com/highcharts/highcharts)  —  A charting library written in pure JavaScript, offering an easy way of adding interactive charts to your web site or web application.. 108 | 109 | It is based on HTML5/SVG/VML, meaning it requires no extra plugins and it also supports a wide range of charts like spline, column, bar, maps, angular gauges among others along with being free for personal use. 110 | 111 |
112 | 113 | [**Hapi**](https://github.com/hapijs/hapi) is a rich framework for building applications and services. It enables developers to focus on writing reusable application logic instead of spending time building infrastructure. 114 | It is a configuration-driven pattern, traditionally modeled to control web server operations. A unique feature Hapi has is the ability to create a server on a specific IP, with features like the onPreHandler, we can do something with a request before it is completed by intercepting it and doing some pre-processing on the request. 115 | 116 | ## I 117 | 118 | [**Impress.js**](https://github.com/impress/impress.js)  —  It's a presentation framework based on the power of CSS3 transforms and transitions in modern browsers. 119 | 120 |
121 | 122 | [**Ink**](https://github.com/vadimdemedes/ink) provides the same component-based UI building experience that React provides, but for command-line apps. 123 | 124 |
125 | 126 | [**Insomnia**](https://github.com/Kong/insomnia) is a desktop cross-platform API client for REST and GraphQL, built on top of Electron. It takes the pain out of interacting with HTTP-based APIs. Insomnia combines an easy-to-use interface with advanced functionality like authentication helpers, code generation, and environment variables. It's an open source alternative to Postman which offers a simpler and cleaner user interface. 127 | 128 | ## J 129 | 130 | [**jasmine**](https://github.com/jasmine/jasmine)  — Simple JavaScript testing framework for browsers and node.js. 131 | 132 | ## L 133 | 134 | [**LaTeX Resume Generator**](https://github.com/saadq/latexresu.me) is an easy to use webapp for creating elegant LaTeX resumes without the need to write any TeX code yourself. Built with Node.js and React. 135 | 136 |
137 | 138 | [**Leaflet**](https://github.com/Leaflet/Leaflet) — The leading open-source JavaScript library for mobile-friendly interactive maps. 139 | 140 |
141 | 142 | [**lodash**](https://github.com/lodash/lodash) — A modern JavaScript utility library delivering modularity, performance, & extras. 143 | 144 | ## M 145 | 146 | [**Mailspring**](https://github.com/Foundry376/Mailspring) is a new version of [Nylas Mail](https://github.com/nylas/nylas-mail) maintained by one of the original authors. It's faster, leaner, and shipping today! It replaces the JavaScript sync code in Nylas Mail with a new C++ sync engine based on Mailcore2. It uses roughly half the RAM and CPU of Nylas Mail and idles with almost zero "CPU Wakes", which translates to great battery life. It also has an entirely revamped composer and other great new features. 147 | 148 | Mailspring's UI is open source (GPLv3) and written in JavaScript with Electron and React - it's built on a plugin architecture and was designed to be easy to extend. 149 | 150 |
151 | 152 | [**Marko**](https://github.com/marko-js/marko) is a friendly and super fast UI library that makes building web apps fun! 153 | 154 |
155 | 156 | [**Moment.js**](https://github.com/moment/moment) — a lightweight JavaScript date library for parsing, validating, manipulating, and formatting dates. 157 | 158 |
159 | 160 | [**Meteor**](https://github.com/meteor/meteor) is an ultra-simple environment for building modern web applications. 161 | 162 | With Meteor you write apps in modern JavaScript that send data over the wire, rather than HTML using your choice of popular open-source libraries 163 | 164 | ## N 165 | [**NSFW**](https://github.com/infinitered/nsfwjs) — Client-side indecent content checking 166 | 167 | A simple JavaScript library to help you quickly identify unseemly images; all in the client's browser. NSFWJS isn't perfect, but it's pretty accurate (~90% from our test set of 15,000 test images)... and it's getting more accurate all the time. 168 | 169 |
170 | 171 | [**NestJS**](https://github.com/nestjs/nest) is a framework for building efficient, scalable Node.js server-side applications. It uses modern JavaScript, is built with TypeScript (preserves compatibility with pure JavaScript) and combines elements of OOP (Object Oriented Programming), FP (Functional Programming), and FRP (Functional Reactive Programming). 172 | 173 | Under the hood, Nest makes use of Express, but also, provides compatibility with a wide range of other libraries, like e.g. Fastify, allowing for easy use of the myriad third-party plugins which are available. 174 | 175 |
176 | 177 | [**Next.js**](https://github.com/vercel/next.js/) is an open-source web development framework created by Vercel enabling React-based web applications with server-side rendering and generating static websites 178 | 179 | Next.js gives you the best developer experience with all the features you need for production: hybrid static & server rendering, TypeScript support, smart bundling, route pre-fetching, and more. No config needed. 180 | 181 | ## P 182 | 183 | [**Phaser**](https://github.com/photonstorm/phaser) 184 | Phaser is a fast, free, and fun open source HTML5 game framework that offers WebGL and Canvas rendering across desktop and mobile web browsers. Games can be compiled to iOS, Android and native apps by using 3rd party tools. You can use JavaScript or TypeScript for development. 185 | 186 | Along with the fantastic open source community, Phaser is actively developed and maintained by Photon Storm. As a result of rapid support, and a developer friendly API, Phaser is currently one of the most starred game frameworks on GitHub. 187 | 188 | Thousands of developers from indie and multi-national digital agencies, and universities worldwide use Phaser. You can take a look at their incredible games. 189 | 190 |
191 | 192 | [**PM2**](http://github.com/Unitech/pm2) is a production process manager for Node.js applications with a built-in load balancer. It allows you to keep applications alive forever, to reload them without downtime and to facilitate common system admin tasks. 193 | 194 |
195 | 196 | [**Popper.js**](https://popper.js.org/) This JavaScript library will help you create delightful poppers on your site. If you’re wondering what a popper is, think of it like a little thought bubble bursting from an element! Popper.js gives you some fantastic ways to arrange them, make them stick to elements, and keep them operating smoothly on any screen size 197 | 198 |
199 | 200 | [**PouchDB**](https://github.com/pouchdb/pouchdb) is an open-source JavaScript database inspired by Apache CouchDB that is designed to run well within the browser. 201 | 202 | PouchDB was created to help web developers build applications that work as well offline as they do online. 203 | It enables applications to store data locally while offline, then synchronize it with CouchDB and compatible servers when the application is back online, keeping the user's data in sync no matter where they next login. 204 | 205 | Usage: 206 | ```javascript 207 | var db = new PouchDB('dbname'); 208 | 209 | db.put({ 210 | _id: 'dave@gmail.com', 211 | name: 'David', 212 | age: 69 213 | }); 214 | 215 | db.changes().on('change', function() { 216 | console.log('Ch-Ch-Changes'); 217 | }); 218 | 219 | db.replicate.to('http://example.com/mydb'); 220 | ``` 221 | 222 | ## R 223 | 224 | [**React**](https://github.com/facebook/react) — React is a JavaScript library for building user interfaces. 225 | 226 | * **Declarative:** React makes it painless to create interactive UIs. Design simple views for each state in your application, and React will efficiently update and render just the right components when your data changes. Declarative views make your code more predictable, simpler to understand, and easier to debug. 227 | * **Component-Based:** Build encapsulated components that manage their own state, then compose them to make complex UIs. Since component logic is written in JavaScript instead of templates, you can easily pass rich data through your app and keep state out of the DOM. 228 | * **Learn Once, Write Anywhere:** We don't make assumptions about the rest of your technology stack, so you can develop new features in React without rewriting existing code. React can also render on the server using Node and power mobile apps using [React Native](https://facebook.github.io/react-native/). 229 | 230 | [Learn how to use React in your own project](https://react.dev/learn). 231 | 232 |
233 | 234 | [**Redux**](https://github.com/facebook/react) — Redux is a predictable state container for JavaScript apps. 235 | 236 | - **Predictability of outcome** There is always one source of truth, the store, with no confusion about how to sync the current state with actions and other parts of the application. 237 | - **Maintainability** Having a predictable outcome and strict structure makes the code easier to maintain. 238 | - **Server rendering** This is very useful, especially for the initial render, making for a better user experience or search engine optimization. Just pass the store created on the server to the client side. 239 | - **Organization** Redux is stricter about how code should be organized, which makes code more consistent and easier for a team to work with. 240 | - **Developer tools** Developers can track everything going on in the app in real time, from actions to state changes. 241 | - **Community and ecosystem** This is a huge plus whenever you’re learning or using any library or framework. Having a community behind Redux makes it even more appealing to use. 242 | - **Ease of testing** The first rule of writing testable code is to write small functions that do only one thing and that are independent. Redux’s code is mostly functions that are just that: small, pure and isolated. 243 | 244 |
245 | 246 | [**Reveal.js**](https://github.com/hakimel/reveal.js) — A framework for easily creating beautiful presentations using HTML. 247 | 248 |
249 | 250 | [**Routing Controllers**](https://github.com/typestack/routing-controllers) — A framework for building backend applications in Node. 251 | 252 | * It is quite lightweight, easy to learn and pleasant to use. 253 | * It allows to create structured, declarative and beautifully organized class-based controllers. 254 | * It has heavy decorators usage providing with efficient logging, functionality, and test performance. 255 | * It can be used easily in Express / Koa using TypeScript. 256 | 257 | 258 | ## S 259 | 260 | [**socket.io**](https://github.com/socketio/socket.io) — Realtime application framework (Node.JS server). 261 | 262 |
263 | 264 | [**Strapi**](https://github.com/strapi/strapi) — The most advanced open-source Content Management Framework (headless-CMS) to build powerful API with no effort. 265 | 266 |
267 | 268 | [**strider**](https://github.com/Strider-CD/strider) — an Open Source Continuous Deployment / Continuous Integration platform. It is written in Node.JS / JavaScript and uses MongoDB as a backing store. It is published under the BSD license. 269 | 270 |
271 | 272 | [**Svelte**](https://github.com/sveltejs/svelte) — Svelte is a UI framework of sorts that borrows a lot of the great ideas from some of its peers like React and Vue.js, but brings about its own interesting ideas to the table. Plus, it’s not entirely a framework in the sense that we’re used to and is perhaps better seen as a compiler. 273 | 274 | 275 |
276 | 277 | [**SweetAlert2**](https://github.com/limonte/sweetalert2) — An awesome replacement for JavaScript's alert. 278 | 279 | [Check out the live demo](https://github.com/limonte/sweetalert2). 280 | 281 |
282 | 283 | [**Serverless Framework**](https://github.com/serverless/serverless) — Build web, mobile and IoT applications with serverless architectures using AWS Lambda, Azure Functions, Google CloudFunctions & more! 284 | 285 | The Framework uses new event-driven compute services, like AWS Lambda, Google Cloud Functions, and more. It's a command-line tool, providing scaffolding, workflow automation and best practices for developing and deploying your serverless architecture. It's also completely extensible via plugins. 286 | 287 | ## T 288 | 289 | [**TestCafe**](https://github.com/DevExpress/testcafe) is a pure node.js end-to-end solution for testing web apps. It takes care of all the stages: starting browsers, running tests, gathering test results and generating reports. TestCafe doesn’t need browser plugins - it works in all popular modern browsers out-of-the-box. 290 | 291 |
292 | 293 | [**Three.js**](https://github.com/mrdoob/three.js) is a cross-browser JavaScript library/API used to create and display animated 3D computer graphics in a web browser. Three.js uses WebGL. 294 | 295 |
296 | 297 | [**Tone.js**](https://github.com/Tonejs/Tone.js) is a framework for creating interactive music in the browser. It provides advanced scheduling capabilities, synths and effects, and intuitive musical abstractions built on top of the Web Audio API. 298 | 299 | [Check out the live demos.](https://tonejs.github.io/demos) 300 | 301 | ## V 302 | 303 | [**Video.js**](https://github.com/videojs/video.js) — An Open source HTML5 & Flash video player. 304 | 305 | > Video.js is a web video player built from the ground up for an HTML5 world. It supports HTML5 and Flash video, as well as YouTube and Vimeo (through [plugins][plugins]). It supports video playback on desktops and mobile devices. This project was started mid 2010, and the player is now used on over ~~50,000~~ ~~100,000~~ ~~200,000~~ [400,000 websites][builtwith]. 306 | 307 |
308 | 309 | [**Vue.js**](https://github.com/vuejs/vue) — Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web. It is designed from the ground up to be incrementally adoptable, and can easily scale between a library and a framework depending on different use cases. It consists of an approachable core library that focuses on the view layer only, and an ecosystem of supporting libraries that helps you tackle complexity in large Single-Page Applications. 310 | 311 | [Learn how to use Vue.js in your own project](https://vuejs.org/v2/guide/). 312 | 313 |
314 | 315 | [**VuePress**](https://github.com/vuejs/vuepress) — VuePress is a Minimalistic Vue-powered static site generator with Vue component based layout and is the latest project from Vue creator Evan You. On the client side, a VuePress site is an SPA powered by Vue, Vue Router and Webpack. It was originally created to support the documentation needs of Vue’s own subprojects and now it can serve your own needs. A VuePress site is in fact a SPA powered by Vue, Vue Router and webpack. If you’ve used Vue before, you will notice the familiar development experience when you are writing or developing custom themes. 316 | 317 | [Learn how to use VuePress - official guide](https://vuepress.vuejs.org/guide). 318 | 319 | ## W 320 | 321 | [**Webpack**](https://github.com/webpack/webpack) — Webpack is a module bundler. Its main purpose is to bundle JavaScript files for usage in a browser, yet it is also capable of transforming, bundling, or packaging just about any resource or asset. 322 | 323 |
324 | 325 | [**web3.js - Ethereum JavaScript API**](https://github.com/ethereum/web3.js/) — web3.js is a collection of libraries which allow you to interact with a local or remote ethereum node, using a HTTP or IPC connection. 326 | 327 |
328 | 329 | [**WebTorrent**](https://github.com/feross/webtorrent) — :zap: Streaming torrent client for the web. 330 | 331 | WebTorrent is a streaming torrent client for node.js and the browser. 332 | 333 | 334 | ## Y 335 | 336 | [**yarn**](https://github.com/yarnpkg/berry) — :package::cat2: Fast, reliable, and secure dependency management. 337 | -------------------------------------------------------------------------------- /languages/KOTLIN.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**Atrium**](https://atriumlib.org/) is a multiplatform assertion library for Kotlin with support for i18n. 4 | 5 | Atrium adds extra information to error messages so that you get quickly a better idea of what went wrong. 6 | For instance, for the following assertion (which fails) 7 | ```kotlin 8 | expect(listOf(1, 2, 3)).contains.inOrder.only.values(1, 3) 9 | ``` 10 | Atrium points out which `values` were found, makes an implicit assertion about the size and also states which entries were additionally contained in the list: 11 | 12 | ```text 13 | expect: [1, 2, 3] (java.util.Arrays$ArrayList <1287934450>) 14 | ◆ contains only, in order: 15 | ✔ ▶ entry 0: 1 (kotlin.Int <6519275>) 16 | ◾ to be: 1 (kotlin.Int <6519275>) 17 | ✘ ▶ entry 1: 2 (kotlin.Int <692331943>) 18 | ◾ to be: 3 (kotlin.Int <692331943>) 19 | ✘ ▶ size: 3 20 | ◾ to be: 2 21 | ❗❗ additional entries detected: 22 | ⚬ entry 2: 3 (kotlin.Int <1741979653>) 23 | ``` 24 | 25 | ## C 26 | 27 | [**Corda**](https://github.com/corda/corda) is an open source blockchain project, designed for business from the start. Only Corda allows you to build interoperable blockchain networks that transact in strict privacy. Corda's smart contract technology allows businesses to transact directly, with value. 28 | 29 | ## J 30 | 31 | [**Jackson**](https://github.com/FasterXML/jackson-module-kotlin) - module that adds support for serialization/deserialization of Kotlin classes and data classes. Previously a default constructor must have existed on the Kotlin object for Jackson to deserialize into the object. With this module, single constructor classes can be used automatically, and those with secondary constructors or static factories are also supported. 32 | 33 | ## K 34 | [**KorGE**](https://github.com/korlibs/korge) is a modern multiplatform game engine for Kotlin. KorGE is fully written in Kotlin. KorGE gradle plugin allows to target each platform natively: JVM for Android, JS for the Web and Native code for iOS and Desktop. KorGE has a very small footprint. It has no external dependencies and only uses the libraries available on each platform. You can create small native games or games for the web, that are fast to download and require almost no space to store. The JS sample of this page is just 383 KB gzipped (1.9 MB uncompressed). No emscripten. Just plain JS generated using Kotlin/JS. Iterate fast, develop with pleasure 35 | Since KorGE targets the JVM, you can develop your game, try it, debug it and test it using IntelliJ IDEA (including Community, Ultimate and Android Studio) integrated debugger. And then deploy to the other targets by using the provided gradle tasks. You can also use KorGE as a library and for example integrated it in your android-only project. Tons of features out of the box 36 | KorGE is just the last layer of a larger stack (Korlibs) for multimedia development: Date and Time utilities, Image Loading, Vector Rasterization, Pathfinding, Sound, Data Structures, Fast Memory Access, Virtual File Systems, WebSockets... Also, it is extensible and include several plugins out of the box: DragonBones, Box2D, SWF and Admob. And more coming. 37 | 38 |
39 | 40 | [**KotlinPoet**](https://github.com/square/kotlinpoet) is a Kotlin and Java API for generating .kt source files. 41 | 42 | Source file generation can be useful when doing things such as annotation processing or interacting with metadata files (e.g., database schemas, protocol formats). By generating code, you eliminate the need to write boilerplate while also keeping a single source of truth for the metadata. 43 | 44 |
45 | 46 | [**Ktor**](https://github.com/ktorio/ktor) is a framework for quickly creating web applications in Kotlin with minimal effort. 47 | 48 | ## L 49 | 50 | [**LibKTX**](https://github.com/libktx/ktx) aims to make LibGDX as Kotlin-friendly as possible without completely rewriting the API. It provides modular utilities and extensions for selected parts of LibGDX with poor native Kotlin support. 51 | 52 | Examples of Kotlin language features used to improve usability, performance and readability of LibGDX APIs include: 53 | 54 | * Operator overloads for collections and mathematical operations. 55 | * Extension methods with sensible default parameters. 56 | * Inline methods with reduced runtime overhead for various listeners, builders and loggers. 57 | * Nullable types which improve typing information of selected interfaces and functions. 58 | * Default interface methods for common interfaces, simplifying their implementations. 59 | * Type-safe builders for GUI, styling and physics engine. 60 | * Coroutines context providing concurrency utilities and non-blocking asset loading. 61 | * Reified types that simplify usage of methods normally consuming Class parameters. 62 | 63 | ## T 64 | 65 | [**Themis**](https://github.com/cossacklabs/themis) - a multi-platform framework for solving typical data security tasks: secure data storage, secure messaging, zero-knowledge proof authentication, etc. Themis has unified easy-to-use hard-to-misuse API for 14 languages and platforms, so it's a best fit for multi-platform apps and apps with end-to-end encryption. It hides cryptographic details, so developers don't need to know the difference between AES CBC mode and AES GCM mode to encrypt the data. Recommended by OWASP MASVS. 66 | 67 | [**TornadoFX**](https://github.com/edvin/tornadofx) - lightweight JavaFX Framework for Kotlin. 68 | * Supports both MVC, MVP and their derivatives 69 | * Dependency injection 70 | * Type safe GUI builders 71 | * Type safe CSS builders 72 | * First class FXML support 73 | * Async task execution 74 | * EventBus with thread targeting 75 | * Hot reload of Views and Stylesheets 76 | * OSGi support 77 | * REST client with automatic JSON conversion 78 | * Zero config, no XML, no annotations 79 | 80 | ## V 81 | 82 | [**Virgil PureKit**](https://github.com/VirgilSecurity/virgil-purekit-java) is an open-source security framework for user passwords and data protection in a database with functionality against online and offline attacks. PureKit can be used within any database or login system that uses a password, so it’s applicable for a company of any industry or size. It's available for several different programming languages, including Kotlin. 83 | -------------------------------------------------------------------------------- /languages/LUA.md: -------------------------------------------------------------------------------- 1 | ## K 2 | 3 | [**Kong**](https://github.com/Kong/kong) —  a cloud-native, platform-agnostic, scalable API Gateway. 4 | 5 | [**KOReader**](https://github.com/koreader/koreader)  —  a document viewer application, originally created for Kindle e-ink readers. It currently runs on Kindle, Kobo, PocketBook, Ubuntu Touch and Android (2.3+) devices. Developers can also run KOReader emulator for development purpose on desktop PC with Linux and Windows and Mac OSX (experimental for now). 6 | 7 | ## L 8 | 9 | [**Lapis**](https://github.com/leafo/lapis) —  a web framework for Lua and OpenResty. 10 | 11 |
12 | 13 | [**Love2D**](https://github.com/love2d/love) - a simple 2D game framework for Lua. 14 | 15 | Example: 16 | 17 | ```lua 18 | function love.load() 19 | whale = love.graphics.newImage('whale.png') 20 | end 21 | 22 | function love.draw() 23 | love.graphics.draw(whale, 300, 200) 24 | end 25 | ``` 26 | 27 | [**luaposix**](https://github.com/luaposix/luaposix) - a wrapper over POSIX function to fill the gaps of lua standard library. This makes lua capable of implementing everything, only with this single library. 28 | 29 |
30 | 31 | [**LuaRocks**](https://github.com/luarocks/luarocks)  —  a package manager for Lua modules. 32 | 33 | ## M 34 | 35 | [**MoonScript**](https://github.com/leafo/moonscript) - a programmer friendly language that compiles into Lua. It gives you the power of the fastest scripting language combined with a rich set of features. 36 | 37 | ## O 38 | 39 | [**OpenResty**](https://github.com/openresty/openresty)  —  a full-fledged web platform by integrating the standard Nginx core, LuaJIT, many carefully written Lua libraries, lots of high quality 3rd-party Nginx modules, and most of their external dependencies. It is designed to help developers easily build scalable web applications, web services, and dynamic web gateways. 40 | 41 | ## S 42 | 43 | [**SILE**](https://github.com/sile-typesetter/sile) — a typesetting system for producing beautiful printed documents. Conceptually, SILE is similar to TeX –from which it borrows some concepts and even syntax and algorithms– but rather than being a derivative of the TeX family SILE is a new typesetting and layout engine written from the ground up using modern technologies and borrowing some ideas from graphical systems such as InDesign. Every aspect of the typesetting engine can be modified and extended using Lua. 44 | 45 | ## T 46 | 47 | [**Telize**](https://github.com/fcambus/telize) —  a REST API built on Nginx and Lua allowing to get a visitor IP address and to query location information from any IP address. It outputs JSON-encoded IP geolocation data, and supports both JSON and JSONP. 48 | 49 | ``` 50 | t e l i z e 51 | _______________________ 52 | ______\ /_______ 53 | \\ \\ ___ // / 54 | __ \ ____ \ __ / \ _____/\ / ____ 55 | ___/ \____/ _//____/ \___\___/___\__ /__/ _//____ 56 | \\__ ____ __/ __ __ ____ ____ __/ __/// 57 | / \_ |/ \_ / \/ /_/ |/ \_ 58 | \\\ ___/\___ /____/\_______/\ ___/\___ / 59 | <0(--- \__/ -h7- \______/ \ . \__/ ---- \______/ --(0> 60 | \ .\ /. . 61 | \ .\ // / 62 | \______\\ //______/ 63 | Y 64 | ``` 65 | -------------------------------------------------------------------------------- /languages/OCAML.md: -------------------------------------------------------------------------------- 1 | ## C 2 | 3 | [**Coq**](https://github.com/coq/coq) is a formal proof management system. It provides a formal language to write mathematical definitions, executable algorithms and theorems together with an environment for semi-interactive development of machine-checked proofs. 4 | 5 | ## F 6 | 7 | [**Flow**](https://github.com/facebook/flow) is a static typechecker for JavaScript. To find out more about Flow, check out flowtype.org. 8 | 9 | ## I 10 | 11 | [**Infer**](https://github.com/facebook/infer) is a static analysis tool for Java, Objective-C and C, written in OCaml. 12 | 13 | ## R 14 | 15 | [**Reason**](https://github.com/facebook/reason) is a alternate syntax for OCaml. It's simple, fast & type safe code that leverages the JavaScript & OCaml ecosystems. 16 | 17 | 18 | [**ReScript**](https://github.com/rescript-lang/rescript-compiler) is a JavaScript backend for OCaml focused on smooth integration and clean generated code. 19 | -------------------------------------------------------------------------------- /languages/R.md: -------------------------------------------------------------------------------- 1 | ## R 2 | 3 | [**Shiny**](https://github.com/rstudio/shiny) is a new package from RStudio that makes it incredibly easy to build interactive web applications with R. Shiny combines the computational power of R with the interactivity of the modern web. 4 | 5 | ## P 6 | 7 | [**plotly**](https://medium.com/@likid.geimfari/the-list-of-interesting-open-source-projects-2daaa2153f7c#.str9sn2ep)  —  an R package for creating interactive web graphics via the open source JavaScript graphing library plotly.js. 8 | 9 | ## T 10 | 11 | [**Tidyverse**](https://github.com/tidyverse/tidyverse/) is a set of R compatible packages covering most modern data science tasks. 12 | -------------------------------------------------------------------------------- /languages/RUBY.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**Aasm**](https://github.com/aasm/aasm) is a library for adding finite state machines to Ruby classes. Aasm started as the acts_as_state_machine plugin but has evolved into a more generic library that no longer targets only ActiveRecord models. It currently provides adapters for many ORMs but it can be used for any Ruby class, no matter what parent class it has (if any). 4 | 5 |
6 | 7 | [**Awesome Print**](https://github.com/awesome-print/awesome_print) Awesome Print is a Ruby library that pretty prints Ruby objects in full color exposing their internal structure with proper indentation. Rails ActiveRecord objects and usage within Rails templates are supported via included mixins. 8 | 9 | ## B 10 | 11 | [**Better Errors**](https://github.com/charliesome/better_errors) replaces the standard Rails error page with a much better and more useful error page. It is also usable outside of Rails in any Rack app as Rack middleware. 12 | 13 |
14 | 15 | [**Bullet**](https://github.com/flyerhzm/bullet) This project is designed to help you increase your application's performance by reducing the number of queries it makes. It will watch your queries while you develop your application and notify you when you should add eager loading (N+1 queries), when you're using eager loading that isn't necessary and when you should use counter cache. 16 | 17 | ## C 18 | 19 | [**CanCanCan**](https://github.com/CanCanCommunity/cancancan) is an authorization library for Ruby >= 2.2.0 and Ruby on Rails >= 4.2 which restricts what resources a given user is allowed to access. 20 | All permissions can be defined in one or multiple ability files and not duplicated across controllers, views, and database queries, keeping your permissions logic in one place for easy maintenance and testing. 21 | 22 |
23 | 24 | [**Capybara**](https://github.com/teamcapybara/capybara) helps you test web applications by simulating how a real user would interact with your app. It is agnostic about the driver running your tests and comes with Rack::Test and Selenium support built in. WebKit is supported through an external gem. 25 | 26 |
27 | 28 | [**Cryptopunks**](https://github.com/cryptopunksnotdead/cryptopunks) Tool to mint your own 24×24 pixel punk images off chain from the True Official Genuine CryptoPunks™ sha256-verified original 10 000 unique character collection. 29 | 30 | ## D 31 | 32 | [**Devise**](https://github.com/plataformatec/devise) is a flexible authentication solution for Rails based on Warden. It: 33 | * is Rack based; 34 | * is a complete MVC solution based on Rails engines; 35 | * allows you to have multiple models signed in at the same time; 36 | * is based on a modularity concept: use only what you really need. 37 | 38 | ## F 39 | 40 | [**FactoryBot**](https://github.com/thoughtbot/factory_bot) is a fixtures replacement with a straightforward definition syntax, support for multiple build strategies (saved instances, unsaved instances, attribute hashes, and stubbed objects), and support for multiple factories for the same class (user, admin_user, and so on), including factory inheritance. 41 | 42 |
43 | 44 | [**Faker**](https://github.com/faker-ruby/faker) is a library to generates random data, used in factories to can test differents cases in the same situation 45 | 46 |
47 | 48 | [**Faraday**](https://github.com/lostisland/faraday) is an HTTP client lib that provides a common interface over many 49 | adapters (such as Net::HTTP) and embraces the concept of Rack middleware when 50 | processing the request/response cycle. 51 | 52 | Faraday supports these adapters: 53 | 54 | * [Net::HTTP][net_http] _(default)_ 55 | * [Net::HTTP::Persistent][persistent] 56 | * [Excon][] 57 | * [Typhoeus][] 58 | * [Patron][] 59 | * [EventMachine][] 60 | * [HTTPClient][] 61 | 62 | It also includes a Rack adapter for hitting loaded Rack applications through 63 | Rack::Test, and a Test adapter for stubbing requests by hand. 64 | 65 | ```ruby 66 | conn = Faraday.new(:url => 'http://sushi.com') do |faraday| 67 | faraday.request :url_encoded # form-encode POST params 68 | faraday.response :logger # log requests to STDOUT 69 | faraday.adapter Faraday.default_adapter # make requests with Net::HTTP 70 | end 71 | 72 | ## GET ## 73 | 74 | response = conn.get '/nigiri/sake.json' # GET http://sushi.com/nigiri/sake.json 75 | response.body 76 | 77 | conn.get '/nigiri', { :name => 'Maguro' } # GET http://sushi.com/nigiri?name=Maguro 78 | 79 | conn.get do |req| # GET http://sushi.com/search?page=2&limit=100 80 | req.url '/search', :page => 2 81 | req.params['limit'] = 100 82 | end 83 | 84 | ## POST ## 85 | 86 | conn.post '/nigiri', { :name => 'Maguro' } # POST "name=maguro" to http://sushi.com/nigiri 87 | 88 | # post payload as JSON instead of "www-form-urlencoded" encoding: 89 | conn.post do |req| 90 | req.url '/nigiri' 91 | req.headers['Content-Type'] = 'application/json' 92 | req.body = '{ "name": "Unagi" }' 93 | end 94 | 95 | ## Per-request options ## 96 | 97 | conn.get do |req| 98 | req.url '/search' 99 | req.options.timeout = 5 # open/read timeout in seconds 100 | req.options.open_timeout = 2 # connection open timeout in seconds 101 | end 102 | ``` 103 | 104 | ## G 105 | 106 | [**Graphql-Ruby**](https://github.com/rmosolgo/graphql-ruby) is a Ruby implementation for Graphql lovers. 107 | 108 | ## H 109 | 110 | [**Huginn**](https://github.com/cantino/huginn) is a system for building agents that perform automated tasks for you online. They can read the web, watch for events, and take actions on your behalf. Huginn's Agents create and consume events, propagating them along a directed graph. Think of it as a hackable Yahoo! Pipes plus IFTTT on your own server. You always know who has your data. You do. 111 | 112 | ## J 113 | 114 | [**Jbuilder**](https://github.com/rails/jbuilder) gives you a simple DSL for declaring JSON structures that beats manipulating giant hash structures. This is particularly helpful when the generation process is fraught with conditionals and loops. 115 | 116 | ## K 117 | 118 | [**Kaminari**](https://github.com/kaminari/kaminari) is a Scope & Engine based, clean, powerful, customizable and sophisticated paginator for modern web app frameworks and ORMs. 119 | 120 | ## M 121 | 122 | [**MetaTags**](https://github.com/kpumuk/meta-tags). Gem to make your Rails application SEO-friendly 123 | 124 | ## O 125 | 126 | [**Octokit**](https://github.com/octokit/octokit.rb) is a library to access the github data and improve yours automation 127 | 128 | 129 | [**Octobox**](https://github.com/octobox/octobox). Take back control of your GitHub Notifications. 130 | 131 | ## P 132 | [**PaperTrail**](https://github.com/paper-trail-gem/paper_trail) is a gem that helps track changes to your models, for auditing or versioning. A few features of this gem are: 133 | 134 | * The PaperTrail gem allows you to track changes made to your Rails models over time. 135 | * Any time a tracked record in your database is changed, it creates a corresponding entry in a PaperTrail::Version table. 136 | * It accomplishes this by tying into the ActiveRecord callback chain and storing a new version when the record is created, updated, or destroyed. 137 | 138 |
139 | 140 | [**Pagy**](https://github.com/ddnexus/pagy) is the coolest pagination gem that outperforms the others in each and every benchmark and comparison. 141 | 142 | * It is 40x times fater than other pagination gems like will_paginate and kaminari. 143 | * It is also 36 times lighter for total memory usage. 144 | * Totally agnostic. It doesn't need to know anything about your models, ORM or storage, so it doesn't add any code to them 145 | 146 |
147 | 148 | [**Pry**](https://github.com/pry/pry) is a powerful alternative to the standard IRB shell for Ruby. It is 149 | written from scratch to provide a number of advanced features, 150 | including: 151 | 152 | * Source code browsing (including core C source with the pry-doc gem) 153 | * Documentation browsing 154 | * Live help system 155 | * Open methods in editors (`edit Class#method`) 156 | * Syntax highlighting 157 | * Command shell integration (start editors, run git, and rake from within Pry) 158 | * Gist integration 159 | * Navigation around state (`cd`, `ls` and friends) 160 | * Runtime invocation (use Pry as a developer console or debugger) 161 | * Exotic object support (BasicObject instances, IClasses, ...) 162 | * A Powerful and flexible command system 163 | * Ability to view and replay history 164 | * Many convenience commands inspired by IPython, Smalltalk and other advanced REPLs 165 | * A wide-range number of [plugins](https://github.com/pry/pry/wiki/Available-plugins) that provide remote sessions, full debugging functionality, and more. 166 | 167 |
168 | 169 | [**Puma**](https://github.com/puma/puma) is a simple, fast, threaded, and highly concurrent HTTP 1.1 server for Ruby/Rack applications. Puma is intended for use in both development and production environments. In order to get the best throughput, it is highly recommended that you use a Ruby implementation with real threads like Rubinius or JRuby. 170 | 171 |
172 | 173 | [**Pundit**](https://github.com/varvet/pundit) is an authorization library for Ruby which restricts what resources a given user is allowed to access. 174 | 175 | ## R 176 | 177 | [**Rails**](https://github.com/rails/rails) a web-application framework that includes everything needed to create database-backed web applications according to the Model-View-Controller (MVC) pattern. Also called Ruby on Rails 178 | Understanding the MVC pattern is key to understanding Rails. MVC divides your application into three layers: Model, View, and Controller, each with a specific responsibility. A great help for developers by allowing them to abstract and simplify common repetitive tasks. 179 | 180 |
181 | 182 | [**Rails ERD**](https://github.com/voormedia/rails-erd) is a gem that allows you to easily generate a diagram based on your application's Active Record models. The diagram gives an overview of how your models are related. Having a diagram that describes your models is perfect documentation for your application. 183 | 184 | ## S 185 | 186 | [**Scientist**](https://github.com/github/scientist) - a Ruby library for carefully refactoring critical paths. 187 | 188 |
189 | 190 | [**Sidekiq**](https://github.com/mperham/sidekiq) uses threads to handle many jobs at the same time in the same process. It does not require Rails but will integrate tightly with Rails to make background processing dead simple. 191 | 192 | Sidekiq is compatible with Resque. It uses the exact same message format as Resque so it can integrate into an existing Resque processing farm. You can have Sidekiq and Resque run side-by-side at the same time and use the Resque client to enqueue jobs in Redis to be processed by Sidekiq. 193 | 194 |
195 | 196 | [**Slim**](https://github.com/slim-template/slim) is a template language whose goal is to reduce the view syntax to the essential parts without becoming cryptic. It started as an exercise to see how much could be removed from a standard html template (<, >, closing tags, etc...). As more people took an interest in Slim, the functionality grew and so did the flexibility of the syntax. 197 | 198 |
199 | 200 | [**Spidr**](https://github.com/postmodern/spidr) is a versatile Ruby web spidering library that can spider a site, multiple domains, certain links or infinitely. Spidr is designed to be fast and easy to use. 201 | 202 |
203 | 204 | [**Solidus**](https://github.com/solidusio/solidus) is a free, open-source ecommerce platform that gives you complete control over your store. 205 | 206 | Have a large community, with more than 670 contribuitors around the world. 207 | 208 | Solidus, Rails eCommerce System. 209 | Site: https://solidus.io/ 210 | 211 |
212 | 213 | [**Sorbet**](https://github.com/sorbet/sorbet) is a powerful type checker for Ruby implemented by Stripe. It introduces type-checking for variables, function arguments, and return values. It helps reduce the number of bugs in software and increases the development speed. 214 | 215 | ## V 216 | 217 | [**vcr**](https://github.com/vcr/vcr). Record your test suite's HTTP interactions and replay them during future test runs for fast, deterministic, accurate tests. 218 | 219 | Usage: 220 | ```ruby 221 | require 'rubygems' 222 | require 'test/unit' 223 | require 'vcr' 224 | 225 | VCR.configure do |config| 226 | config.cassette_library_dir = "fixtures/vcr_cassettes" 227 | config.hook_into :webmock 228 | end 229 | 230 | class VCRTest < Test::Unit::TestCase 231 | def test_example_dot_com 232 | VCR.use_cassette("synopsis") do 233 | response = Net::HTTP.get_response(URI('http://www.iana.org/domains/reserved')) 234 | assert_match /Example domains/, response.body 235 | end 236 | end 237 | end 238 | ``` 239 | -------------------------------------------------------------------------------- /languages/RUST.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**Actix**](https://github.com/actix/actix) is a Rust actors framework. 4 | 5 |
6 | 7 | [**Actix web**](https://github.com/actix/actix-web) is a simple, pragmatic and extremely fast web framework for Rust. 8 | 9 | **Features**: 10 | 11 | * Supported *HTTP/1.x* and [*HTTP/2.0*](https://actix.rs/docs/http2/) protocols 12 | * Streaming and pipelining 13 | * Keep-alive and slow requests handling 14 | * Client/server [WebSockets](https://actix.rs/docs/websockets/) support 15 | * Transparent content compression/decompression (br, gzip, deflate) 16 | * Configurable [request routing](https://actix.rs/docs/url-dispatch/) 17 | * Graceful server shutdown 18 | * Multipart streams 19 | * Static assets 20 | * SSL support with OpenSSL or `native-tls` 21 | * Middlewares ([Logger, Session, CORS, CSRF, etc](https://actix.rs/docs/middleware/)) 22 | * Includes an asynchronous [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html) 23 | * Built on top of [Actix actor framework](https://github.com/actix/actix) 24 | 25 |
26 | 27 | [**Alacritty**](https://github.com/jwilm/alacritty) is focused on simplicity and performance. The performance goal means it should be faster than any other terminal emulator available. The simplicity goal means that it doesn't have many features like tabs or scroll back as in other terminals. Instead, it is expected that users of Alacritty make use of a terminal multiplexer such as tmux. 28 | 29 | This initial release should be considered to be pre-alpha software--it will have issues. Once Alacritty reaches an alpha level of readiness, precompiled binaries will be provided for supported operating systems. 30 | 31 |
32 | 33 | [**Amethyst**](https://github.com/amethyst/amethyst) is a data-driven and data-oriented game engine aiming to be fast and as configurable as possible written in Rust. 34 | 35 | **Principles**: 36 | 37 | * Massively parallel architecture 38 | * Powered by a correct [Entity Component System](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system) model 39 | * Rapid prototyping with [RON](https://github.com/ron-rs/ron) files for prefabs and an abstract scripting API 40 | * Strong focus on encouraging reusability and clean interfaces 41 | 42 | ## B 43 | 44 | [**bat**](https://github.com/sharkdp/bat) is a `cat` replacement with extended features like syntax highlighting and git integration. 45 | 46 |
47 | 48 | [**bevy**](https://github.com/bevyengine/bevy) is a refreshingly simple data-driven game engine built in Rust. 49 | 50 | ## C 51 | 52 | [**Clippy**](https://github.com/rust-lang/rust-clippy) is a collection of lints to catch common mistakes and improve your Rust code. 53 | 54 |
55 | 56 | [**coreutils**](https://github.com/uutils/coreutils) is an attempt at writing universal (as in cross-platform) CLI utils in Rust. This repo is to aggregate the GNU coreutils rewrites. 57 | 58 |
59 | 60 | [**Cursive**](https://github.com/gyscos/Cursive) is a TUI (Text User Interface) library for rust, which allows you to build rich user interfaces for terminal applications. 61 | 62 | Example of usage: 63 | 64 | ```rust 65 | extern crate cursive; 66 | 67 | use cursive::Cursive; 68 | use cursive::views::{Dialog, TextView}; 69 | 70 | fn main() { 71 | // Creates the cursive root - required for every application. 72 | let mut siv = Cursive::new(); 73 | 74 | // Creates a dialog with a single "Quit" button 75 | siv.add_layer(Dialog::around(TextView::new("Hello Dialog!")) 76 | .title("Cursive") 77 | .button("Quit", |s| s.quit())); 78 | 79 | // Starts the event loop. 80 | siv.run(); 81 | } 82 | ``` 83 | 84 | ## D 85 | 86 | [**Deno**](https://github.com/denoland/deno) is a simple, modern and secure runtime for JavaScript, TypeScript, and WebAssembly that uses V8 and is built in Rust. 87 | 88 |
89 | 90 | [**Diesel**](https://github.com/diesel-rs/diesel) gets rid of the boilerplate for database interaction and eliminates runtime errors, without sacrificing performance. It takes full advantage of Rust's type system to create a low overhead query builder that "feels like Rust". 91 | 92 | ## E 93 | 94 | [**exa**](https://the.exa.website/) is a replacement for `ls` written in Rust. 95 | 96 |
97 | 98 | [**Exonum**](https://github.com/exonum/exonum) is an extensible open-source framework for creating blockchain applications. Exonum can be used to create cryptographically powered distributed ledgers in virtually any problem domain, including FinTech, GovTech, and LegalTech. The Exonum framework is oriented towards creating permissioned blockchains, that is, blockchains with the known set of blockchain infrastructure providers. 99 | 100 | ## F 101 | 102 | [**fd**](https://github.com/sharkdp/fd) is a simple, fast and user-friendly alternative to find. 103 | 104 | Features: 105 | * Convenient syntax: `fd PATTERN` instead of `find -iname '*PATTERN*'`. 106 | * Colorized terminal output (similar to *ls*). 107 | * It's *fast*. 108 | * Smart case: the search is case-insensitive by default. It switches to 109 | case-sensitive if the pattern contains an uppercase 110 | character[\*](http://vimdoc.sourceforge.net/htmldoc/options.html#'smartcase'). 111 | * Ignores hidden directories and files, by default. 112 | * Ignores patterns from your `.gitignore`, by default. 113 | * Regular expressions. 114 | * Unicode-awareness. 115 | * The command name is *50%* shorter[\*](https://github.com/ggreer/the_silver_searcher) than 116 | `find` :-). 117 | * Parallel command execution with a syntax similar to GNU Parallel. 118 | 119 |
120 | 121 | [**fselect**](https://github.com/jhspetersson/fselect) is a command-line tool to search files with SQL-like queries. 122 | 123 | Why use fselect? Because it has these nice features: 124 | 125 | * complex queries 126 | * SQL-like (not real SQL, but highly relaxed!) grammar easily understandable by humans 127 | * search within archives 128 | * `.gitignore` support (experimental) 129 | * search by width and height of images and videos 130 | * search by MP3 info 131 | * shortcuts to common file types 132 | * various output formatting (CSV, JSON, and others) 133 | 134 | ## G 135 | 136 | [**Gotham**](https://github.com/gotham-rs/gotham) - A flexible web framework that does not sacrifice safety, security or speed. The Gotham core team loves many of the elegant concepts that are found in dynamically typed web application frameworks, such as Rails, Phoenix and Django and aspire to achieve them with the type and memory safety guarantees provided by Rust. 137 | 138 | ## H 139 | 140 | [**Habitat**](https://github.com/habitat-sh/habitat) is an application automation framework that allows you to build applications that have automation built-in. This provides modern applications that: 141 | 142 | - Provide repeatable builds 143 | - Run from single, immutable assets 144 | - Allow for runtime configuration for multiple deployment scenarios 145 | - Are agnostic to operating environment (works the same on bare metal, virtualization, containers, PaaS) 146 | - Provide idempotent behavior (the same inputs to the same asset provide the same outcome) 147 | - Provide convergent behavior (each service makes progress towards the correct behavior in the face of failure) 148 | - Expose promises to those who rely on it 149 | - Provide a low barrier to entry 150 | - Are language agnostic 151 | 152 |
153 | 154 | [**hyper**](https://github.com/hyperium/hyper) is a fast, modern HTTP implementation written in and for Rust. It is a low-level typesafe abstraction over raw HTTP, providing an elegant layer over "stringly-typed" HTTP. 155 | 156 | Hyper offers both an HTTP client and server which can be used to drive complex web applications written entirely in Rust. 157 | 158 | Be aware that hyper is still actively evolving towards 1.0, and is likely to experience breaking changes before stabilising. The current area of change is the movement towards async IO and refining the design around that. You can also see the 1.0 issue milestone. 159 | 160 | ## I 161 | 162 | [**Iron**](https://github.com/iron/iron) - is a high level web framework built in and for Rust, built on [Hyper](https://github.com/hyperium/hyper). Iron is designed to take advantage of Rust's greatest features - its excellent type system and its principled approach to ownership in both single threaded and multi threaded contexts. 163 | 164 | Example of usage: 165 | ```rust 166 | extern crate iron; 167 | 168 | use iron::prelude::*; 169 | use iron::status; 170 | 171 | fn main() { 172 | fn hello_world(_: &mut Request) -> IronResult { 173 | Ok(Response::with((status::Ok, "Hello World!"))) 174 | } 175 | 176 | let _server = Iron::new(hello_world).http("localhost:3000").unwrap(); 177 | println!("On 3000"); 178 | } 179 | ``` 180 | 181 | ## M 182 | 183 | [**Mio**](https://github.com/carllerche/mio) is a lightweight I/O library for Rust with a focus on adding as little overhead as possible over the OS abstractions. 184 | 185 | ## N 186 | 187 | [**nickel.rs**](https://github.com/nickel-org/nickel.rs) is a simple and lightweight foundation for web applications written in Rust. Its API is inspired by the popular express framework for JavaScript. 188 | 189 | Usage example: 190 | 191 | ```rust 192 | #[macro_use] extern crate nickel; 193 | 194 | use nickel::{Nickel, HttpRouter}; 195 | 196 | fn main() { 197 | let mut server = Nickel::new(); 198 | server.get("**", middleware!("Hello World")); 199 | server.listen("127.0.0.1:6767"); 200 | } 201 | ``` 202 | 203 |
204 | 205 | [**nom**](https://github.com/Geal/nom) is a parser combinators library written in Rust. Its goal is to provide tools to build safe parsers without compromising the speed or memory consumption. To that end, it uses extensively Rust's strong typing, zero copy parsing, push streaming, pull streaming, and provides macros and traits to abstract most of the error prone plumbing. 206 | 207 |
208 | 209 | [**nushell**](https://github.com/nushell/nushell) - A modern shell for the GitHub era. 210 | ![](https://github.com/nushell/nushell/blob/master/images/nushell-autocomplete.gif) 211 | 212 | ## P 213 | 214 | [**Parity**](https://github.com/paritytech/parity) - fast, light, and robust Ethereum client. 215 | 216 | ## R 217 | 218 | [**RACER**](https://github.com/racer-rust/racer) is a utility intended to provide Rust code completion for editors and IDEs. Maybe one day the 'er' bit will be exploring + refactoring or something. 219 | 220 |
221 | 222 | [**Rayon**](https://github.com/rayon-rs/rayon) is a data-parallelism library for Rust. It is extremely lightweight and makes it easy to convert a sequential computation into a parallel one. It also guarantees data-race freedom. 223 | 224 |
225 | 226 | [**redox**](https://github.com/redox-os/redox)  —  an operating system written in Rust, a language with focus on safety and high performance. Redox, following the microkernel design, aims to be secure, usable, and free. Redox is inspired by previous kernels and operating systems, such as SeL4, Minix, Plan 9, and BSD. 227 | 228 |
229 | 230 | [**ripgrep**](https://github.com/BurntSushi/ripgrep) — a line oriented search tool that combines the usability of The Silver Searcher (similar to ack) with the raw speed of GNU grep. ripgrep works by recursively searching your current directory for a regex pattern. ripgrep has first class support on Windows, Mac and Linux, with binary downloads available for every release. 231 | 232 | Detailed benchmarks [show](http://blog.burntsushi.net/ripgrep/) that it is the fastest avaiable tool of this kind. 233 | 234 |
235 | 236 | [**Rocket**](https://github.com/SergioBenitez/Rocket) is web framework for Rust (nightly) with a focus on ease-of-use, expressibility, and speed. Here's an example of a complete Rocket application: 237 | 238 | ```rust 239 | #![feature(plugin, decl_macro)] 240 | #![plugin(rocket_codegen)] 241 | 242 | extern crate rocket; 243 | 244 | #[get("//")] 245 | fn hello(name: String, age: u8) -> String { 246 | format!("Hello, {} year old named {}!", age, name) 247 | } 248 | 249 | fn main() { 250 | rocket::ignite().mount("/hello", routes![hello]).launch(); 251 | } 252 | ``` 253 | 254 |
255 | 256 | [**rustup**](https://github.com/rust-lang-nursery/rustup.rs) installs The Rust Programming Language from the official release channels, enabling you to easily switch between stable, beta, and nightly compilers and keep them updated. It makes cross-compiling simpler with binary builds of the standard library for common platforms. And it runs on all platforms Rust supports, including Windows. 257 | 258 | ## S 259 | 260 | [**Serde**](https://github.com/serde-rs/serde) is a framework for serializing and deserializing Rust data structures efficiently and generically. 261 | 262 | Example of usage: 263 | ```rust 264 | #[macro_use] 265 | extern crate serde_derive; 266 | 267 | extern crate serde; 268 | extern crate serde_json; 269 | 270 | #[derive(Serialize, Deserialize, Debug)] 271 | struct Point { 272 | x: i32, 273 | y: i32, 274 | } 275 | 276 | fn main() { 277 | let point = Point { x: 1, y: 2 }; 278 | 279 | // Convert the Point to a JSON string. 280 | let serialized = serde_json::to_string(&point).unwrap(); 281 | 282 | // Prints serialized = {"x":1,"y":2} 283 | println!("serialized = {}", serialized); 284 | 285 | // Convert the JSON string back to a Point. 286 | let deserialized: Point = serde_json::from_str(&serialized).unwrap(); 287 | 288 | // Prints deserialized = Point { x: 1, y: 2 } 289 | println!("deserialized = {:?}", deserialized); 290 | } 291 | ``` 292 | 293 |
294 | 295 | [**Servo**](https://github.com/servo/servo) is a prototype web browser engine written in the Rust language. It is currently developed on 64-bit macOS, 64-bit Linux, 64-bit Windows, and Android.. 296 | 297 |
298 | 299 | [**sled**](https://github.com/spacejam/sled) - likes eating data: alpha modern embedded database. 300 | 301 | **Features**: 302 | 303 | * ordered map API 304 | * fully atomic single-key operations, supports CAS 305 | * merge operators 306 | * [zstd](https://github.com/facebook/zstd) compression (use the zstd build feature) 307 | * cpu-scalable lock-free implementation 308 | * SSD-optimized log-structured storage 309 | 310 |
311 | 312 | [**Starship**](https://github.com/starship/starship) is a minimal, blazing-fast, and infinitely customizable prompt for any shell. 313 | 314 | - **Fast:** it's fast – _really really_ fast! 🚀 315 | - **Customizable:** configure every aspect of your prompt. 316 | - **Universal:** works on any shell, on any operating system. 317 | - **Intelligent:** shows relevant information at a glance. 318 | - **Feature rich:** support for all your favorite tools. 319 | - **Easy:** quick to install – start using it in minutes. 320 | 321 |
322 | 323 | [**stdweb**](https://github.com/koute/stdweb) is a set of bindings to the client-side Web APIs which makes it easy to interact with the DOM, embed JavaScript code directly into Rust and to marshal data between the two. Supports WebAssembly. 324 | 325 | A few simple examples of what you can do with it: 326 | 327 | ```rust 328 | let message = "Hello, 世界!"; 329 | let result = js! { 330 | alert( @{message} ); 331 | return 2 + 2 * 2; 332 | }; 333 | 334 | println!( "2 + 2 * 2 = {:?}", result ); 335 | ``` 336 | 337 | ```rust 338 | let button = document().query_selector( "#hide-button" ).unwrap(); 339 | button.add_event_listener( move |_: ClickEvent| { 340 | for anchor in document().query_selector_all( "#main a" ) { 341 | js!( @{anchor}.style = "display: none;"; ); 342 | } 343 | }); 344 | ``` 345 | 346 | ## T 347 | 348 | [**TiKV**](https://github.com/pingcap/tikv) is a distributed Key-Value database which is based on the design of Google Spanner and HBase, but it is much simpler without dependency on any distributed file system. With the implementation of the Raft consensus algorithm in Rust and consensus state stored in RocksDB, it guarantees data consistency. Placement Driver which is introduced to implement sharding enables automatic data migration. The transaction model is similar to Google's Percolator with some performance improvements. TiKV also provides snapshot isolation (SI), snapshot isolation with lock (SQL: select ... for update), and externally consistent reads and writes in distributed transactions. 349 | 350 | ## X 351 | 352 | [**xi editor**](https://github.com/google/xi-editor) is an attempt to build a high quality text editor, using modern software engineering techniques. It is initially built for Mac OS X, using Cocoa for the user interface, but other targets are planned. 353 | 354 | ## Y 355 | 356 | [**Yew**](https://github.com/DenisKolodin/yew) is a modern Rust framework inspired by Elm and ReactJS. 357 | -------------------------------------------------------------------------------- /languages/SCALA.md: -------------------------------------------------------------------------------- 1 | ## Scala 2 | 3 | [**GitBucket**](https://github.com/gitbucket/gitbucket)  —  a Git platform powered by Scala with easy installation, high extensibility & github API compatibility. 4 | 5 |
6 | 7 | [**Finatra**](https://github.com/twitter/finatra)  —  a lightweight framework for building fast, testable, scala applications on top of TwitterServer and Finagle. Finatra provides an easy-to-use API for creating and testing Finagle servers and apps as well as powerful JSON support, modern logging via SLF4J, Finagle client utilities, and more. 8 | 9 |
10 | 11 | [**Scalatra**](https://github.com/scalatra/scalatra) is a tiny, Sinatra-like web framework for Scala. 12 | 13 | Example: 14 | 15 | ```scala 16 | import org.scalatra._ 17 | 18 | class ScalatraExample extends ScalatraServlet { 19 | get("/") { 20 |

Hello, world!

21 | } 22 | } 23 | ``` 24 | 25 |
26 | 27 | [**algebird** ](https://github.com/twitter/algebird) —  an abstract algebra for Scala. This code is targeted at building aggregation systems (via Scalding or Apache Storm). It was originally developed as part of Scalding’s Matrix API, where Matrices had values which are elements of Monoids, Groups, or Rings. Subsequently, it was clear that the code had broader application within Scalding and on other projects within Twitter. 28 | 29 |
30 | 31 | The [**Play**](https://github.com/playframework/playframework) Framework combines productivity and performance making it easy to build scalable web applications with Java and Scala. Play is developer friendly with a "just hit refresh" workflow and built-in testing support. With Play, applications scale predictably due to a stateless and non-blocking architecture. By being RESTful by default, including assets compilers, JSON & WebSocket support, Play is a perfect fit for modern web & mobile applications. 32 | 33 |
34 | 35 | [**Ammonite**](https://github.com/lihaoyi/ammonite) - Ammonite lets you use the Scala language for scripting purposes: in the REPL, as scripts, as a library to use in existing projects, or as a standalone systems shell. 36 | 37 |
38 | 39 | [**bitcoin-s-core**](https://github.com/bitcoin-s/bitcoin-s-core) - An implementation of the Bitcoin protocol in Scala. 40 | 41 |
42 | 43 | [**Apache Spark**](https://github.com/apache/spark) - a unified analytics engine for large-scale data processing. It provides high-level APIs in Scala, Java, Python, and R, and an optimized engine that supports general computation graphs for data analysis. It also supports a rich set of higher-level tools including Spark SQL for SQL and DataFrames, MLlib for machine learning, GraphX for graph processing, and Structured Streaming for stream processing. 44 |
45 | 46 | [**Lila**](https://github.com/lichess-org/lila) - Lila (li[chess in sca]la) is a free online chess game server used by [Lichess.org](https://lichess.org) as its main backend. Lila is focused on realtime gameplay and ease of use. 47 | -------------------------------------------------------------------------------- /languages/SHELL.md: -------------------------------------------------------------------------------- 1 | ## D 2 | 3 | [**dokku**](https://github.com/dokku/dokku) is a docker powered mini-Heroku. The smallest PaaS implementation you’ve ever seen. 4 | 5 | ## G 6 | 7 | [**git-secret**](https://github.com/sobolevn/git-secret)  —  a bash tool to store your private data inside a git repo. How’s that? Basically, it just encrypts, using gpg, the tracked files with the public keys of all the users that you trust. So everyone of them can decrypt these files using only their personal secret key. Why deal with all this private-public keys stuff? Well, to make it easier for everyone to manage access rights. There are no passwords that change. When someone is out - just delete his public key, re-encrypt the files, and he won’t be able to decrypt secrets anymore. 8 | 9 | ## K 10 | 11 | [**Kerl**](https://github.com/kerl/kerl). Easy building and installing of Erlang/OTP instances. Kerl aims to be shell agnostic and its only dependencies, excluding what's required to actually build Erlang/OTP, are curl and git. All is done so that, once a specific release has been built, creating a new installation is as fast as possible. 12 | 13 | ## M 14 | 15 | [**Mal**](https://github.com/kanaka/mal). Mal is a Clojure inspired Lisp interpreter 16 | 17 | ## N 18 | 19 | [**Neofetch**](https://github.com/dylanaraps/neofetch) is a command-line system information tool written in bash 3.2+. 20 | Neofetch displays information about your operating system, software and hardware in an aesthetic and visually pleasing way. 21 | 22 | The overall purpose of Neofetch is to be used in screen-shots of your system. Neofetch shows the information other people want to see. 23 | There are other tools available for proper system statistic/diagnostics. 24 | 25 | The information by default is displayed alongside your operating system's logo. 26 | You can further configure Neofetch to instead use an image, a custom ASCII file, your wallpaper or nothing at all. 27 | 28 |
29 | 30 | [**nvm**](https://github.com/nvm-sh/nvm) allows you to quickly install and use different versions of node via the command line. 31 | ```sh 32 | $ nvm use 16 33 | Now using node v16.9.1 (npm v7.21.1) 34 | $ node -v 35 | v16.9.1 36 | $ nvm use 14 37 | Now using node v14.18.0 (npm v6.14.15) 38 | $ node -v 39 | v14.18.0 40 | $ nvm install 12 41 | Now using node v12.22.6 (npm v6.14.5) 42 | $ node -v 43 | v12.22.6 44 | ``` 45 | 46 | ## O 47 | 48 | [**oh-my-zsh**](https://github.com/robbyrussell/oh-my-zsh) - a delightful community-driven (with 1,000+ contributors) framework for managing your zsh configuration. Includes 200+ optional plugins (rails, git, OSX, hub, capistrano, brew, ant, php, python, etc), over 140 themes to spice up your morning, and an auto-update tool so that makes it easy to keep up with the latest updates from the community. 49 | 50 | ## P 51 | 52 | [**Prezto**](https://github.com/sorin-ionescu/prezto) is a configuration framework for Zsh. It comes supplied with a variety of plugins and themes that can extend and customise your shell. 53 | 54 |
55 | 56 | [**pyenv**](https://github.com/yyuu/pyenv) lets you easily switch between multiple versions of Python. It’s simple, unobtrusive, and follows the UNIX tradition of single-purpose tools that do one thing well. 57 | 58 | -------------------------------------------------------------------------------- /languages/SOLIDITY.md: -------------------------------------------------------------------------------- 1 | ## Solidity 2 | 3 | [**Truffle**](https://github.com/trufflesuite/truffle) Truffle is a development environment, testing framework and asset pipeline for Ethereum, aiming to make life as an Ethereum developer easier. 4 | 5 | Reasons to use Truffle 6 | - Built-in smart contract compilation, linking, deployment and binary management. 7 | - Automated contract testing with Mocha and Chai. 8 | - Configurable build pipeline with support for custom build processes. 9 | - Scriptable deployment & migrations framework. 10 | - Network management for deploying to many public & private networks. 11 | - Interactive console for direct contract communication. 12 | - Instant rebuilding of assets during development. 13 | - External script runner that executes scripts within a Truffle environment. -------------------------------------------------------------------------------- /languages/SVG.md: -------------------------------------------------------------------------------- 1 | ## I 2 | 3 | [**icons**](https://github.com/twbs/icons)  —  Official open source SVG icon library for Bootstrap with over 1,400 icons. 4 | 5 | ## S 6 | 7 | [**StyledIcons**](https://github.com/styled-icons/styled-icons)  — Awesome, Material Design, and Octicons, available as React Styled Components.Available in various styles and topics. 8 | 9 | [**SuperTinyIcons**](https://github.com/edent/SuperTinyIcons)  —  Super Tiny Web Icons are minuscule SVG versions of your favourite logos. The average size is under 465 bytes! 10 | The logos have a 512x512 viewbox, they will fit in a circle with radius 256. 11 | -------------------------------------------------------------------------------- /languages/SWIFT.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**Alamofire**](https://github.com/Alamofire/Alamofire)  —  an HTTP networking library written in Swift. 4 | 5 | ## C 6 | 7 | [**Carthage**](https://github.com/Carthage/Carthage) is intended to be the simplest way to add frameworks to your Cocoa application. 8 | 9 | Carthage builds your dependencies and provides you with binary frameworks, but you retain full control over your project structure and setup. Carthage does not automatically modify your project files or your build settings. 10 | 11 | ## E 12 | 13 | [**Eureka**](https://github.com/xmartlabs/Eureka)  is an elegant iOS form builder in Swift. 14 | 15 | ## H 16 | 17 | [**Hero**](https://github.com/lkzhao/Hero) is a library for building iOS view controller transitions. It provides a layer on top of the UIKit's cumbersome transition APIs. Making custom transitions an easy task for developers. 18 | 19 | ## I 20 | 21 | [**IINA**](https://github.com/lhc70000/iina) is the modern video player for macOS. 22 | 23 | ## K 24 | 25 | [**Kingfisher**](https://github.com/onevcat/Kingfisher) is a lightweight, pure-Swift library for downloading and caching images from the web. This project is heavily inspired by the popular SDWebImage. It provides you a chance to use a pure-Swift alternative in your next app. 26 | 27 | ## N 28 | 29 | [**Nuke**](https://github.com/kean/Nuke)  —  Nuke provides an efficient way to download and display images in your app. It's easy to learn and use. Its architecture enables many powerful features while offering virtually unlimited possibilities for customization. 30 | 31 | ## Q 32 | 33 | [**Quick**](https://github.com/Quick/Quick) is a behavior-driven development framework for Swift and Objective-C. Inspired by RSpec, Specta, and Ginkgo. 34 | 35 | ## S 36 | 37 | [**SwiftLint**](https://github.com/realm/SwiftLint)  —  a tool to enforce Swift style and conventions. 38 | 39 | ## T 40 | 41 | [**Themis**](https://github.com/cossacklabs/themis) - a multi-platform framework for solving typical data security tasks: secure data storage, secure messaging, zero-knowledge proof authentication, etc. Themis has unified easy-to-use hard-to-misuse API for 14 languages and platforms, so it's a best fit for multi-platform apps and apps with end-to-end encryption. It hides cryptographic details, so developers don't need to know the difference between AES CBC mode and AES GCM mode to encrypt the data. Recommended by OWASP MASVS. 42 | 43 | ## V 44 | 45 | [**Vapor**](https://github.com/vapor/vapor) —  the most used web framework for Swift. It provides a beautifully expressive and easy to use foundation for your next website, API, or cloud project. 46 | -------------------------------------------------------------------------------- /languages/TYPESCRIPT.md: -------------------------------------------------------------------------------- 1 | ## A 2 | 3 | [**Activepieces**](https://github.com/activepieces/activepieces)  —  No-code business automation tool written in Typescript and Angualr. 4 | 5 | MIT-licensed no-code businsess automation tool like Zapier that can be hosted on your machine to keep your data on prem. 6 | 7 |
8 | 9 | [**Angular**](https://github.com/angular/angular)  —  The successor to AngularJS. 10 | 11 | Angular is a development platform for building mobile and desktop web applications. 12 | 13 |
14 | 15 | [**Angular Material**](https://github.com/angular/material2)  —  Material Design components for Angular 2. 16 | 17 | Angular Material brings high-quality UI components built with Angular 2 and TypeScript, following the Material Design spec. These components will serve as an example of how to write Angular code following best practices. 18 | 19 |
20 | 21 | [**Amplication**](https://github.com/amplication/amplication) - Open-source low code tool that builds Node.js applications in few clicks. 22 | 23 | Amplication is an open‑source development tool. It helps professional Node.js developers develop quality Node.js applications without spending time on repetitive coding tasks. 24 | 25 | Amplication auto-generates backend apps built with TypeScript and Node.js, and a client built with React. 26 | 27 | ## I 28 | 29 | [**Ionic**](https://github.com/driftyco/ionic)  —  A complete mobile toolkit, built for web developers. 30 | 31 | Know how to build websites? Then you already know how to build mobile apps. Ionic Framework offers the best web and native app components for building highly interactive native and progressive web apps with Angular. 32 | 33 | ## N 34 | 35 | [**NativeScript**](https://github.com/NativeScript/NativeScript)  —  Framework to develop mobile apps for iOS and Android platforms. 36 | 37 | NativeScript empowers you to access native APIs from JavaScript directly. The framework currently provides iOS and Android runtimes for rich mobile development and can be utilized in a number of diverse use cases. 38 | 39 | ## Q 40 | 41 | [**qwik**](https://github.com/BuilderIO/qwik) - The HTML-first framework. Instant apps of any size with ~ 1kb JS 42 | 43 | Qwik is a new kind of web framework that can deliver instant loading web applications at any size or complexity. Your sites and apps can boot with about 1kb of JS (regardless of application complexity), and achieve consistent performance at scale. Qwik is so fast because it allows fully interactive sites to load with almost no JavaScript and pickup from where the server left off. 44 | 45 | As users interact with the site, only the necessary parts of the site load on-demand. This precision lazy-loading is what makes Qwik so quick. 46 | 47 | ## R 48 | 49 | [**RxJS**](https://github.com/ReactiveX/rxjs) - A reactive programming library for JavaScript 50 | 51 | RxJS is a library for reactive programming using Observables, to make it easier to compose asynchronous or callback-based code. This project is a rewrite of Reactive-Extensions/RxJS with better performance, better modularity, better debuggable call stacks, while staying mostly backwards compatible, with some breaking changes that reduce the API surface 52 | 53 | ## S 54 | 55 | [**Solid**](https://github.com/solidjs/solid)  —  A declarative, efficient, and flexible JavaScript library for building user interfaces. 56 | 57 | Solid is a declarative JavaScript library for creating user interfaces. Instead of using a Virtual DOM, it compiles its templates to real DOM nodes and updates them with fine-grained reactions. Declare your state and use it throughout your app, and when a piece of state changes, only the code that depends on it will rerun. 58 | 59 |
60 | 61 | [**Storybook**](https://github.com/storybookjs/storybook)  —  Storybook is a frontend workshop for building UI components and pages in isolation. Made for UI development, testing, and documentation. 62 | 63 |
64 | 65 | [**Stryker**](https://github.com/stryker-mutator/stryker)  —  A mutation testing framework for JavaScript. 66 | 67 | Stryker enables you to measure the quality of your unit tests by using a technique called mutation testing. Stryker will insert small bugs (mutations) into your code and check if your tests can detect the bugs. 68 | 69 | ## T 70 | 71 | [**TypeScript**](https://github.com/Microsoft/TypeScript) - The language itself. 72 | 73 | TypeScript is a language for application-scale JavaScript. TypeScript adds optional types, classes, and modules to JavaScript. TypeScript supports tools for large-scale JavaScript applications for any browser, for any host, on any OS. TypeScript compiles to readable, standards-based JavaScript. 74 | 75 |
76 | 77 | [**TypeScriptToLua**](https://github.com/TypeScriptToLua/TypeScriptToLua) - A TypeScript to Lua transpiler. 78 | 79 | A generic TypeScript to Lua transpiler. Write your code in TypeScript and publish Lua! 80 | 81 | Large projects written in lua can become hard to maintain and make it easy to make mistakes. Writing code in TypeScript instead improves maintainability, readability and robustness, with the added bonus of good IDE support. This project is useful in any environment where Lua code is accepted, with the powerful option of simply declaring any existing API using TypeScript declaration files. 82 | 83 |
84 | 85 | [**tinyhttp**](https://github.com/talentlessguy/tinyhttp) — modern Express-like web-framework. 86 | 87 | tinyhttp is a modern Express-like web framework written in TypeScript and compiled to native ESM, that uses a bare minimum amount of dependencies trying to avoid legacy hell. 88 | 89 | Nowadays most of the JavaScript applications, both backend or frontend, are filled with a lot of `node_modules` bloat. While modern Node.js versions support almost all latest JavaScript features, frameworks still pull garbage dependencies like `array-flatten`, even though it has been added to Node in 2018. tinyhttp tries to solve this problem by not relying on any polyfills and targeting the latest stable ECMAScript standard (ES2019 is supported by Node 12 LTS). Moreover, the framework targets both CommonJS legacy modules and modern standard ESM modules which you can use in both LTS and modern versions of Node with no extra setup required. 90 | 91 | ## V 92 | 93 | [**Visual Studio Code**](https://github.com/Microsoft/vscode) - Open source code editor. 94 | 95 | Visual Studio Code combines the simplicity of a source code editor with powerful developer tooling, like IntelliSense code completion and debugging. 96 | First and foremost, it is an editor that gets out of your way. The delightfully frictionless edit-build-debug cycle means less time fiddling with your environment, and more time executing on your ideas. 97 | 98 |
99 | 100 | [**Vue.js**](https://github.com/vuejs/vue) - The Progressive JavaScript Framework 101 | 102 | Vue (pronounced /vjuː/, like view) is a **progressive framework** for building user interfaces. It is designed from the ground up to be incrementally adoptable, and can easily scale between a library and a framework depending on different use cases. It consists of an approachable core library that focuses on the view layer only, and an ecosystem of supporting libraries that helps you tackle complexity in large Single-Page Applications. 103 | 104 |
105 | 106 | [**Vite**](https://github.com/vitejs/vite) - Next generation frontend tooling. It's fast! 107 | 108 | Vite (French word for "quick", pronounced /vit/, like "veet") is a build tool that aims to provide a faster and leaner development experience for modern web projects. It consists of two major parts: 109 | - A dev server that provides rich feature enhancements over native ES modules, for example extremely fast Hot Module Replacement (HMR). 110 | - A build command that bundles your code with Rollup, pre-configured to output highly optimized static assets for production. 111 | Vite is opinionated and comes with sensible defaults out of the box, but is also highly extensible via its Plugin API and JavaScript API with full typing support. 112 | 113 | ## X 114 | 115 | [**Xterm.js**](https://github.com/xtermjs/xterm.js) - A terminal frontend for the web platform 116 | 117 | Xterm.js is a terminal component that powers many standalone and integrated terminals such as Visual Studio Code, Hyper and Theia. 118 | --------------------------------------------------------------------------------