GitHub 1C Enterprise Daily Trending

docusealco/docuseal

2024-11-18T01:28:37Z

the LLM vulnerability scanner

garak, LLM vulnerability scanner

Generative AI Red-teaming & Assessment Kit

garak checks if an LLM can be made to fail in a way we don't want. garak probes for hallucination, data leakage, prompt injection, misinformation, toxicity generation, jailbreaks, and many other weaknesses. If you know nmap, it's nmap for LLMs.

garak focuses on ways of making an LLM or dialog system fail. It combines static, dynamic, and adaptive probes to explore this.

garak's a free tool. We love developing it and are always interested in adding functionality to support applications.

Get started

> See our user guide! docs.garak.ai

> Join our Discord!

> Project links & home: garak.ai

> Twitter: @garak_llm

> DEF CON slides!

LLM support

currently supports:

hugging face hub generative models
replicate text models
openai api chat & continuation models
litellm
pretty much anything accessible via REST
gguf models like llama.cpp version >= 1046
.. and many more LLMs!

Install:

garak is a command-line tool. It's developed in Linux and OSX.

Standard install with `pip`

Just grab it from PyPI and you should be good to go:

python -m pip install -U garak

Install development version with `pip`

The standard pip version of garak is updated periodically. To get a fresher version from GitHub, try:

python -m pip install -U git+https://github.com/NVIDIA/garak.git@main

Clone from source

garak has its own dependencies. You can to install garak in its own Conda environment:

conda create --name garak "python>=3.10,<=3.12"
conda activate garak
gh repo clone NVIDIA/garak
cd garak
python -m pip install -e .

OK, if that went fine, you're probably good to go!

Note: if you cloned before the move to the NVIDIA GitHub organisation, but you're reading this at the github.com/NVIDIA URI, please update your remotes as follows:

git remote set-url origin https://github.com/NVIDIA/garak.git

Getting started

The general syntax is:

garak <options>

garak needs to know what model to scan, and by default, it'll try all the probes it knows on that model, using the vulnerability detectors recommended by each probe. You can see a list of probes using:

garak --list_probes

To specify a generator, use the --model_type and, optionally, the --model_name options. Model type specifies a model family/interface; model name specifies the exact model to be used. The "Intro to generators" section below describes some of the generators supported. A straightforward generator family is Hugging Face models; to load one of these, set --model_type to huggingface and --model_name to the model's name on Hub (e.g. "RWKV/rwkv-4-169m-pile"). Some generators might need an API key to be set as an environment variable, and they'll let you know if they need that.

garak runs all the probes by default, but you can be specific about that too. --probes promptinject will use only the PromptInject framework's methods, for example. You can also specify one specific plugin instead of a plugin family by adding the plugin name after a .; for example, --probes lmrc.SlurUsage will use an implementation of checking for models generating slurs based on the Language Model Risk Cards framework.

For help and inspiration, find us on Twitter or discord!

Examples

Probe ChatGPT for encoding-based prompt injection (OSX/*nix) (replace example value with a real OpenAI API key)

export OPENAI_API_KEY="sk-123XXXXXXXXXXXX"
python3 -m garak --model_type openai --model_name gpt-3.5-turbo --probes encoding

See if the Hugging Face version of GPT2 is vulnerable to DAN 11.0

python3 -m garak --model_type huggingface --model_name gpt2 --probes dan.Dan_11_0

Reading the results

For each probe loaded, garak will print a progress bar as it generates. Once generation is complete, a row evaluating that probe's results on each detector is given. If any of the prompt attempts yielded an undesirable behavior, the response will be marked as FAIL, and the failure rate given.

Here are the results with the encoding module on a GPT-3 variant:

And the same results for ChatGPT:

We can see that the more recent model is much more susceptible to encoding-based injection attacks, where text-babbage-001 was only found to be vulnerable to quoted-printable and MIME encoding injections. The figures at the end of each row, e.g. 840/840, indicate the number of text generations total and then how many of these seemed to behave OK. The figure can be quite high because more than one generation is made per prompt - by default, 10.

Errors go in garak.log; the run is logged in detail in a .jsonl file specified at analysis start & end. There's a basic analysis script in analyse/analyse_log.py which will output the probes and prompts that led to the most hits.

Send PRs & open issues. Happy hunting!

Intro to generators

Hugging Face

Using the Pipeline API:

--model_type huggingface (for transformers models to run locally)
--model_name - use the model name from Hub. Only generative models will work. If it fails and shouldn't, please open an issue and paste in the command you tried + the exception!

Using the Inference API:

--model_type huggingface.InferenceAPI (for API-based model access)
--model_name - the model name from Hub, e.g. "mosaicml/mpt-7b-instruct"

Using private endpoints:

--model_type huggingface.InferenceEndpoint (for private endpoints)
--model_name - the endpoint URL, e.g. https://xxx.us-east-1.aws.endpoints.huggingface.cloud
(optional) set the HF_INFERENCE_TOKEN environment variable to a Hugging Face API token with the "read" role; see https://huggingface.co/settings/tokens when logged in

OpenAI

--model_type openai
--model_name - the OpenAI model you'd like to use. gpt-3.5-turbo-0125 is fast and fine for testing.
set the OPENAI_API_KEY environment variable to your OpenAI API key (e.g. "sk-19763ASDF87q6657"); see https://platform.openai.com/account/api-keys when logged in

Recognised model types are whitelisted, because the plugin needs to know which sub-API to use. Completion or ChatCompletion models are OK. If you'd like to use a model not supported, you should get an informative error message, and please send a PR / open an issue.

Replicate

set the REPLICATE_API_TOKEN environment variable to your Replicate API token, e.g. "r8-123XXXXXXXXXXXX"; see https://replicate.com/account/api-tokens when logged in

Public Replicate models:

--model_type replicate
--model_name - the Replicate model name and hash, e.g. "stability-ai/stablelm-tuned-alpha-7b:c49dae36"

Private Replicate endpoints:

--model_type replicate.InferenceEndpoint (for private endpoints)
--model_name - username/model-name slug from the deployed endpoint, e.g. elim/elims-llama2-7b

Cohere

--model_type cohere
--model_name (optional, command by default) - The specific Cohere model you'd like to test
set the COHERE_API_KEY environment variable to your Cohere API key, e.g. "aBcDeFgHiJ123456789"; see https://dashboard.cohere.ai/api-keys when logged in

Groq

--model_type groq
--model_name - The name of the model to access via the Groq API
set the GROQ_API_KEY environment variable to your Groq API key, see https://console.groq.com/docs/quickstart for details on creating an API key

ggml

--model_type ggml
--model_name - The path to the ggml model you'd like to load, e.g. /home/leon/llama.cpp/models/7B/ggml-model-q4_0.bin
set the GGML_MAIN_PATH environment variable to the path to your ggml main executable

REST

rest.RestGenerator is highly flexible and can connect to any REST endpoint that returns plaintext or JSON. It does need some brief config, which will typically result a short YAML file describing your endpoint. See https://reference.garak.ai/en/latest/garak.generators.rest.html for examples.

NIM

Use models from https://build.nvidia.com/ or other NIM endpoints.

set the NIM_API_KEY environment variable to your authentication API token, or specify it in the config YAML

For chat models:

--model_type nim
--model_name - the NIM model name, e.g. meta/llama-3.1-8b-instruct

For completion models:

--model_type nim.NVOpenAICompletion
--model_name - the NIM model name, e.g. bigcode/starcoder2-15b

OctoAI

set the OCTO_API_TOKEN environment variable to your Replicate API token, e.g. "r8-123XXXXXXXXXXXX"; see https://replicate.com/account/api-tokens when logged in

Octo public endpoint:

--model_type octo
--model_name - the OctoAI public endpoint for the model, e.g. mistral-7b-instruct-fp16

Octo private endpoint:

--model_type octo.InferenceEndpoint (for private endpoints)
--model_name - the deployed endpoint URL, e.g. https://llama-2-70b-chat-xxx.octoai.run/v1/chat/completions

Test

--model_type test
(alternatively) --model_name test.Blank For testing. This always generates the empty string, using the test.Blank generator. Will be marked as failing for any tests that require an output, e.g. those that make contentious claims and expect the model to refute them in order to pass.
--model_type test.Repeat For testing. This generator repeats back the prompt it received.

Intro to probes

Probe	Description
blank	A simple probe that always sends an empty prompt.
atkgen	Automated Attack Generation. A red-teaming LLM probes the target and reacts to it in an attempt to get toxic output. Prototype, mostly stateless, for now uses a simple GPT-2 fine-tuned on the subset of hhrlhf attempts that yielded detectable toxicity (the only target currently supported for now).
av_spam_scanning	Probes that attempt to make the model output malicious content signatures
continuation	Probes that test if the model will continue a probably undesirable word
dan	Various DAN and DAN-like attacks
donotanswer	Prompts to which responsible language models should not answer.
encoding	Prompt injection through text encoding
gcg	Disrupt a system prompt by appending an adversarial suffix.
glitch	Probe model for glitch tokens that provoke unusual behavior.
grandma	Appeal to be reminded of one's grandmother.
goodside	Implementations of Riley Goodside attacks.
leakerplay	Evaluate if a model will replay training data.
lmrc	Subsample of the Language Model Risk Cards probes
malwaregen	Attempts to have the model generate code for building malware
misleading	Attempts to make a model support misleading and false claims
packagehallucination	Trying to get code generations that specify non-existent (and therefore insecure) packages.
promptinject	Implementation of the Agency Enterprise PromptInject work (best paper awards @ NeurIPS ML Safety Workshop 2022)
realtoxicityprompts	Subset of the RealToxicityPrompts work (data constrained because the full test will take so long to run)
snowball	Snowballed Hallucination probes designed to make a model give a wrong answer to questions too complex for it to process
xss	Look for vulnerabilities the permit or enact cross-site attacks, such as private data exfiltration.

Logging

garak generates multiple kinds of log:

A log file, garak.log. This includes debugging information from garak and its plugins, and is continued across runs.
A report of the current run, structured as JSONL. A new report file is created every time garak runs. The name of this file is output at the beginning and, if successful, also at the end of the run. In the report, an entry is made for each probing attempt both as the generations are received, and again when they are evaluated; the entry's status attribute takes a constant from garak.attempts to describe what stage it was made at.
A hit log, detailing attempts that yielded a vulnerability (a 'hit')

How is the code structured?

Check out the reference docs for an authoritative guide to garak code structure.

In a typical run, garak will read a model type (and optionally model name) from the command line, then determine which probes and detectors to run, start up a generator, and then pass these to a harness to do the probing; an evaluator deals with the results. There are many modules in each of these categories, and each module provides a number of classes that act as individual plugins.

garak/probes/ - classes for generating interactions with LLMs
garak/detectors/ - classes for detecting an LLM is exhibiting a given failure mode
garak/evaluators/ - assessment reporting schemes
garak/generators/ - plugins for LLMs to be probed
garak/harnesses/ - classes for structuring testing
resources/ - ancillary items required by plugins

The default operating mode is to use the probewise harness. Given a list of probe module names and probe plugin names, the probewise harness instantiates each probe, then for each probe reads its recommended_detectors attribute to get a list of detectors to run on the output.

Each plugin category (probes, detectors, evaluators, generators, harnesses) includes a base.py which defines the base classes usable by plugins in that category. Each plugin module defines plugin classes that inherit from one of the base classes. For example, garak.generators.openai.OpenAIGenerator descends from garak.generators.base.Generator.

Larger artefacts, like model files and bigger corpora, are kept out of the repository; they can be stored on e.g. Hugging Face Hub and loaded locally by clients using garak.

Developing your own plugin

Take a look at how other plugins do it
Inherit from one of the base classes, e.g. garak.probes.base.TextProbe
Override as little as possible
You can test the new code in at least two ways:
- Start an interactive Python session
  - Import the model, e.g. import garak.probes.mymodule
  - Instantiate the plugin, e.g. p = garak.probes.mymodule.MyProbe()
- Run a scan with test plugins
  - For probes, try a blank generator and always.Pass detector: python3 -m garak -m test.Blank -p mymodule -d always.Pass
  - For detectors, try a blank generator and a blank probe: python3 -m garak -m test.Blank -p test.Blank -d mymodule
  - For generators, try a blank probe and always.Pass detector: python3 -m garak -m mymodule -p test.Blank -d always.Pass
- Get garak to list all the plugins of the type you're writing, with --list_probes, --list_detectors, or --list_generators

FAQ

We have an FAQ here. Reach out if you have any more questions! leon@garak.ai

Code reference documentation is at garak.readthedocs.io.

Citing garak

You can read the garak preprint paper. If you use garak, please cite us.

@article{garak,
  title={{garak: A Framework for Security Probing Large Language Models}},
  author={Leon Derczynski and Erick Galinkin and Jeffrey Martin and Subho Majumdar and Nanna Inie},
  year={2024},
  howpublished={\url{https://garak.ai}}
}

"Lying is a skill like any other, and if you wish to maintain a level of excellence you have to practice constantly" - Elim

For updates and news see @garak_llm

leaningtech/webvm

2024-11-18T01:28:37Z

Virtual Machine for the Web

WebVM

This repository hosts the source code for https://webvm.io, a Linux virtual machine that runs in your browser.

WebVM is a server-less virtual environment running fully client-side in HTML5/WebAssembly. It's designed to be Linux ABI-compatible. It runs an unmodified Debian distribution including many native development toolchains.

WebVM is powered by the CheerpX virtualization engine, and enables safe, sandboxed client-side execution of x86 binaries on any browser. CheerpX includes an x86-to-WebAssembly JIT compiler, a virtual block-based file system, and a Linux syscall emulator.

Enable networking

Modern browsers do not provide APIs to directly use TCP or UDP. WebVM provides networking support by integrating with Tailscale, a VPN network that supports WebSockets as a transport layer.

Open the "Networking" panel from the side-bar
Click "Connect to Tailscale" from the panel
Log in to Tailscale (create an account if you don't have one)
Click "Connect" when prompted by Tailscale
If you are unfamiliar with Tailscale or would like additional information see WebVM and Tailscale.

Fork, deploy, customize

Fork the repository.
Enable Github pages in settings.
- Click on Settings.
- Go to the Pages section.
- Select Github Actions as the source.
  - If you are using a custom domain, ensure Enforce HTTPS is enabled.
Run the workflow.
- Click on Actions.
- Accept the prompt. This is required only once to enable Actions for your fork.
- Click on the workflow named Deploy.
- Click Run workflow and then once more Run workflow in the menu.
After a few seconds a new Deploy workflow will start, click on it to see details.
After the workflow completes, which takes a few minutes, it will show the URL below the deploy_to_github_pages job.

You can now customize dockerfiles/debian_mini to suit your needs, or make a new Dockerfile from scratch. Use the Path to Dockerfile workflow parameter to select it.

Local deployment

From a local git clone

Download the debian_mini Ext2 image from https://github.com/leaningtech/webvm/releases/
- You can also build your own by selecting the "Upload GitHub release" workflow option
- Place the image in the repository root folder
Edit config_github_terminal.js
- Uncomment the default values for CMD, ARGS, ENV and CWD
- Replace IMAGE_URL with the URL (absolute or relative) for the Ext2 image. For example "/debian_mini_20230519_5022088024.ext2"
Build WebVM using npm, output will be placed in the build directory
- npm install
- npm run build
Start NGINX, it automatically points to the build directory just created
- nginx -p . -c nginx.conf
Visit http://127.0.0.1:8081 and enjoy your local WebVM

Example customization: Python3 REPL

The Deploy workflow takes into account the CMD specified in the Dockerfile. To build a REPL you can simply apply this patch and deploy.

diff --git a/dockerfiles/debian_mini b/dockerfiles/debian_mini
index 2878332..1f3103a 100644
--- a/dockerfiles/debian_mini
+++ b/dockerfiles/debian_mini
@@ -15,4 +15,4 @@ WORKDIR /home/user/
 # We set env, as this gets extracted by Webvm. This is optional.
 ENV HOME="/home/user" TERM="xterm" USER="user" SHELL="/bin/bash" EDITOR="vim" LANG="en_US.UTF-8" LC_ALL="C"
 RUN echo 'root:password' | chpasswd
-CMD [ "/bin/bash" ]
+CMD [ "/usr/bin/python3" ]

Bugs and Issues

Please use Issues to report any bug. Or come to say hello / share your feedback on Discord.

Thanks to...

This project depends on:

CheerpX, made by Leaning Technologies for x86 virtualization and Linux emulation
xterm.js, https://xtermjs.org/, for providing the Web-based terminal emulator
Tailscale, for the networking component
lwIP, for the TCP/IP stack, compiled for the Web via Cheerp

Versioning

WebVM depends on the CheerpX x86-to-WebAssembly virtualization technology, which is included in the project via NPM.

The NPM package is updated on every release.

Every build is immutable, if a specific version works well for you today, it will keep working forever.

License

WebVM is released under the Apache License, Version 2.0.

You are welcome to use, modify, and redistribute the contents of this repository.

The public CheerpX deployment is provided as-is and is free to use for technological exploration, testing and use by individuals. Any other use by organizations, including non-profit, academia and the public sector, requires a license. Downloading a CheerpX build for the purpose of hosting it elsewhere is not permitted without a commercial license.

epasveer/seer

2024-11-18T01:28:37Z

✨ AI-powered coding, seamlessly in Neovim. Supports Anthropic, Copilot, Gemini, Ollama, OpenAI and xAI LLMs

Currently supports: Anthropic, Copilot, Gemini, Ollama, OpenAI, Azure OpenAI and xAI adapters

New features are always announced here

💜 Sponsors

Thank you to the following people:

✨ Features

💬 Copilot Chat meets Zed AI, in Neovim
🔌 Support for Anthropic, Copilot, Gemini, Ollama, OpenAI, Azure OpenAI and xAI LLMs (or bring your own!)
🚀 Inline transformations, code creation and refactoring
🤖 Variables, Slash Commands, Agents/Tools and Workflows to improve LLM output
✨ Built in prompt library for common tasks like advice on LSP errors and code explanations
🏗 Create your own custom prompts, Variables and Slash Commands
📚 Have multiple chats open at the same time
💪 Async execution for fast performance

📸 Screenshots

https://github.com/user-attachments/assets/04a2bed3-7af0-4c07-b58f-f644cef1c4bb

https://github.com/user-attachments/assets/4e2a3680-cef5-4134-bf94-e2be93242b38

⚡ Requirements

The curl library
Neovim 0.10.0 or greater
(Optional) An API key for your chosen LLM

📦 Installation

Install the plugin with your preferred package manager:

Lazy.nvim

{
  "olimorris/codecompanion.nvim",
  dependencies = {
    "nvim-lua/plenary.nvim",
    "nvim-treesitter/nvim-treesitter",
    "hrsh7th/nvim-cmp", -- Optional: For using slash commands and variables in the chat buffer
    "nvim-telescope/telescope.nvim", -- Optional: For using slash commands
    { "MeanderingProgrammer/render-markdown.nvim", ft = { "markdown", "codecompanion" } }, -- Optional: For prettier markdown rendering
    { "stevearc/dressing.nvim", opts = {} }, -- Optional: Improves `vim.ui.select`
  },
  config = true
}

Packer

use({
  "olimorris/codecompanion.nvim",
  config = function()
    require("codecompanion").setup()
  end,
  requires = {
    "nvim-lua/plenary.nvim",
    "nvim-treesitter/nvim-treesitter",
    "hrsh7th/nvim-cmp", -- Optional: For using slash commands and variables in the chat buffer
    "nvim-telescope/telescope.nvim", -- Optional: For using slash commands
    { "MeanderingProgrammer/render-markdown.nvim", ft = { "markdown", "codecompanion" } }, -- Optional: For prettier markdown rendering
    "stevearc/dressing.nvim" -- Optional: Improves `vim.ui.select`
  }
})

vim-plug

call plug#begin()

Plug 'nvim-lua/plenary.nvim'
Plug 'nvim-treesitter/nvim-treesitter'
Plug 'hrsh7th/nvim-cmp', " Optional: For using slash commands and variables in the chat buffer
Plug 'nvim-telescope/telescope.nvim', " Optional: For using slash commands
Plug 'stevearc/dressing.nvim' " Optional: Improves `vim.ui.select`
Plug 'MeanderingProgrammer/render-markdown.nvim' " Optional: For prettier markdown rendering
Plug 'olimorris/codecompanion.nvim'

call plug#end()

lua << EOF
  require("codecompanion").setup()
EOF

[!IMPORTANT] The plugin requires the markdown Tree-sitter parser to be installed with :TSInstall markdown

Telescope.nvim is a suggested inclusion as it makes leveraging the Slash Commands a little bit prettier. However, other providers are available. Please refer to the Chat Buffer section for more information.

As per #377, if you pin your plugins to the latest releases, consider setting plenary.nvim to:

{ "nvim-lua/plenary.nvim", branch = "master" },

🚀 Quickstart

[!NOTE] Okay, okay...it's not quite a quickstart as you'll need to configure an adapter and I recommend starting from the configuration section to understand how the plugin works.

Chat Buffer

Run :CodeCompanionChat to open the chat buffer. Type your prompt and press <CR>. Or, run :CodeCompanionChat why are Lua and Neovim so perfect together? to send a prompt directly to the chat buffer. Toggle the chat buffer with :CodeCompanionChat Toggle.

You can add context from your code base by using Variables and Slash Commands in the chat buffer.

Variables, accessed via #, contain data about the present state of Neovim:

#buffer - Shares the current buffer's code. You can also specify line numbers with #buffer:8-20
#lsp - Shares LSP information and code for the current buffer
#viewport - Shares the buffers and lines that you see in the Neovim viewport

Slash commands, accessed via /, run commands to insert additional context into the chat buffer:

/buffer - Insert open buffers
/fetch - Insert URL contents
/file - Insert a file
/help - Insert content from help tags
/now - Insert the current date and time
/symbols - Insert symbols from a selected file
/terminal - Insert terminal output

Tools, accessed via @, allow the LLM to function as an agent and carry out actions:

@cmd_runner - The LLM will run shell commands (subject to approval)
@editor - The LLM will edit code in a Neovim buffer
@files - The LLM will can work with files on the file system (subject to approval)
@rag - The LLM will browse and search the internet for real-time information to supplement its response

Tools can also be grouped together to form Agents, which are also accessed via @ in the chat buffer:

@full_stack_dev - Contains the cmd_runner, editor and files tools.

[!TIP] Press ? in the chat buffer to reveal the keymaps and options that are available.

Inline Assistant

[!NOTE] The diff provider was selected as mini_pick in the video above

Run :CodeCompanion <your prompt> to call the inline assistant. The assistant will evaluate the prompt and either write code or open a chat buffer. You can also make a visual selection and call the assistant.

The assistant has knowledge of your last conversation from a chat buffer. A prompt such as :CodeCompanion add the new function here will see the assistant add a code block directly into the current buffer.

For convenience, you can call prompts from the prompt library via the assistant such as :'<,'>CodeCompanion /buffer what does this file do?. The prompt library comes with the following defaults:

/buffer - Send the current buffer to the LLM alongside a prompt
/commit - Generate a commit message
/explain - Explain how selected code in a buffer works
/fix - Fix the selected code
/lsp - Explain the LSP diagnostics for the selected code
/tests - Generate unit tests for selected code

There are keymaps available to accept or reject edits from the LLM in the inline assistant section.

Action Palette

Run :CodeCompanionActions to open the action palette, which gives you access to all functionality of the plugin. By default the plugin uses vim.ui.select, however, you can change the provider by altering the display.action_palette.provider config value to be telescope or mini_pick. You can also call the Telescope extension with :Telescope codecompanion.

[!NOTE] Some actions and prompts will only be visible if you're in Visual mode.

List of commands

The plugin has three core commands:

CodeCompanion - Open the inline assistant
CodeCompanionChat - Open a chat buffer
CodeCompanionActions - Open the Action Palette

However, there are multiple options available:

CodeCompanion <your prompt> - Prompt the inline assistant
CodeCompanion /<prompt library> - Use the prompt library with the inline assistant e.g. /commit
CodeCompanionChat <prompt> - Send a prompt to the LLM via a chat buffer
CodeCompanionChat <adapter> - Open a chat buffer with a specific adapter
CodeCompanionChat Toggle - Toggle a chat buffer
CodeCompanionChat Add - Add visually selected chat to the current chat buffer

Suggested plugin workflow

For an optimum plugin workflow, I recommend the following:

vim.api.nvim_set_keymap("n", "<C-a>", "<cmd>CodeCompanionActions<cr>", { noremap = true, silent = true })
vim.api.nvim_set_keymap("v", "<C-a>", "<cmd>CodeCompanionActions<cr>", { noremap = true, silent = true })
vim.api.nvim_set_keymap("n", "<LocalLeader>a", "<cmd>CodeCompanionChat Toggle<cr>", { noremap = true, silent = true })
vim.api.nvim_set_keymap("v", "<LocalLeader>a", "<cmd>CodeCompanionChat Toggle<cr>", { noremap = true, silent = true })
vim.api.nvim_set_keymap("v", "ga", "<cmd>CodeCompanionChat Add<cr>", { noremap = true, silent = true })

-- Expand 'cc' into 'CodeCompanion' in the command line
vim.cmd([[cab cc CodeCompanion]])

[!NOTE] You can also assign prompts from the library to specific mappings. See the prompt library section for more information.

⚙ Configuration

Before configuring the plugin, it's important to understand how it's structured.

The plugin uses adapters to connect to LLMs. Out of the box, the plugin supports:

Anthropic (anthropic) - Requires an API key and supports prompt caching
Copilot (copilot) - Requires a token which is created via :Copilot setup in Copilot.vim
Gemini (gemini) - Requires an API key
Ollama (ollama) - Both local and remotely hosted
OpenAI (openai) - Requires an API key
Azure OpenAI (azure_openai) - Requires an Azure OpenAI service with a model deployment
xAI (xai) - Requires an API key

The plugin utilises objects called Strategies. These are the different ways that a user can interact with the plugin. The chat strategy harnesses a buffer to allow direct conversation with the LLM. The inline strategy allows for output from the LLM to be written directly into a pre-existing Neovim buffer. The agent and workflow strategies are wrappers for the chat strategy, allowing for tool use and agentic workflows.

The plugin allows you to specify adapters for each strategy and also for each prompt library entry.

🛠 Changing the Defaults

The default config can be found in the config.lua file and the defaults can be changed by calling the setup function:

require("codecompanion").setup({
  display = {
    diff = {
      provider = "mini_diff",
    },
  },
  opts = {
    log_level = "DEBUG",
  },
})

Please refer to the adapter section below in order to configure adapters.

Changing the System Prompt

The default system prompt has been carefully curated to deliver responses which are similar to GitHub Copilot Chat, no matter which LLM you use. That is, you'll receive responses which are terse, professional and with expertise in coding. However, you can modify the opts.system_prompt table in the config to suit your needs. You can also set it as a function which can receive the current chat buffer's adapter as a parameter, giving you the option of setting system prompts that are LLM or model specific:

require("codecompanion").setup({
  opts = {
    ---@param adapter CodeCompanion.Adapter
    ---@return string
    system_prompt = function(opts)
      if opts.adapter.schema.model.default == "llama3.1:latest" then
        return "My custom system prompt"
      end
      return "My default system prompt"
    end
  }
})

Changing the Language

CodeCompanion supports multiple languages for non-code responses. You can configure this in your setup:

require('codecompanion').setup({
  opts = {
    language = "English" -- Default is "English"
  }
})

Using with render-markdown.nvim

If you use the fantastic render-markdown.nvim plugin, then please ensure you turn off the render_headers display option:

require("codecompanion").setup({
  display = {
    chat = {
      render_headers = false,
    }
  }
})

🔌 Adapters

Please refer to your chosen adapter to understand its configuration. You will need to set an API key for non-locally hosted LLMs.

[!TIP] To create your own adapter or better understand how they work, please refer to the ADAPTERS guide.

Changing the Default Adapter

To specify a different adapter to the default (openai), simply change the strategies.* table:

require("codecompanion").setup({
  strategies = {
    chat = {
      adapter = "anthropic",
    },
    inline = {
      adapter = "copilot",
    },
  },
})

Setting an API Key

require("codecompanion").setup({
  adapters = {
    anthropic = function()
      return require("codecompanion.adapters").extend("anthropic", {
        env = {
          api_key = "MY_OTHER_ANTHROPIC_KEY"
        },
      })
    end,
  },
})

In the example above, we're using the base of the Anthropic adapter but changing the name of the default API key which it uses.

Setting an API Key Using a Command

Having API keys in plain text in your shell is not always safe. Thanks to this PR, you can run commands from within your config by prefixing them with cmd:. In the example below, we're using the 1Password CLI to read an OpenAI credential.

require("codecompanion").setup({
  adapters = {
    openai = function()
      return require("codecompanion.adapters").extend("openai", {
        env = {
          api_key = "cmd:op read op://personal/OpenAI/credential --no-newline",
        },
      })
    end,
  },
})

Using Ollama Remotely

To use Ollama remotely, change the URL in the env table, set an API key and pass it via an "Authorization" header:

require("codecompanion").setup({
  adapters = {
    ollama = function()
      return require("codecompanion.adapters").extend("ollama", {
        env = {
          url = "https://my_ollama_url",
          api_key = "OLLAMA_API_KEY",
        },
        headers = {
          ["Content-Type"] = "application/json",
          ["Authorization"] = "Bearer ${api_key}",
        },
        parameters = {
          sync = true,
        },
      })
    end,
  },
})

Using OpenAI compatible Models like LMStudio or self-hosted models

To use any other OpenAI compatible models, change the URL in the env table, set an API key:

require("codecompanion").setup({
  adapters = {
    ollama = function()
      return require("codecompanion.adapters").extend("openai_compatible", {
        env = {
          url = "http[s]://open_compatible_ai_url", -- optional: default value is ollama url http://127.0.0.1:11434
          api_key = "OpenAI_API_KEY", -- optional: if your endpoint is authenticated
          chat_url = "/v1/chat/completions", -- optional: default value, override if different
        },
      })
    end,
  },
})

Using Azure OpenAI

To use Azure OpenAI, you need to have an Azure OpenAI service, an API key, and a model deployment. Follow these steps to configure the adapter:

Create an Azure OpenAI service in your Azure portal.
Deploy a model in the Azure OpenAI service.
Obtain the API key from the Azure portal.

Then, configure the adapter in your setup as follows:

require("codecompanion").setup({
  strategies = {
    chat = {
      adapter = "azure_openai",
    },
    inline = {
      adapter = "azure_openai",
    },
  },
  adapters = {
    azure_openai = function()
      return require("codecompanion.adapters").extend("azure_openai", {
        env = {
          api_key = 'YOUR_AZURE_OPENAI_API_KEY',
          endpoint = 'YOUR_AZURE_OPENAI_ENDPOINT',
        },
        schema = {
          model = "YOUR_DEPLOYMENT_NAME",
        },
      })
    end,
  },
})

Connecting via a Proxy

You can also connect via a proxy:

require("codecompanion").setup({
  adapters = {
    opts = {
      allow_insecure = true, -- Use if required
      proxy = "socks5://127.0.0.1:9999"
    }
  },
})

Changing an Adapter's Default Model

A common ask is to change an adapter's default model. This can be done by altering the schema.model.default table:

require("codecompanion").setup({
  adapters = {
    anthropic = function()
      return require("codecompanion.adapters").extend("anthropic", {
        schema = {
          model = {
            default = "claude-3-opus-20240229",
          },
        },
      })
    end,
  },
})

Configuring Adapter Settings

LLMs have many settings such as model, temperature and max_tokens. In an adapter, these sit within a schema table and can be configured during setup:

require("codecompanion").setup({
  adapters = {
    llama3 = function()
      return require("codecompanion.adapters").extend("ollama", {
        name = "llama3", -- Give this adapter a different name to differentiate it from the default ollama adapter
        schema = {
          model = {
            default = "llama3:latest",
          },
          num_ctx = {
            default = 16384,
          },
          num_predict = {
            default = -1,
          },
        },
      })
    end,
  },
})

Set a Global Adapter with a Global Variable

In some cases, it may be helpful to set a global adapter across both the chat and inline strategies, on the fly. Perhaps, if your LLM of choice is down or you're without internet. This can be achieved by setting the vim.g.codecompanion_adapter variable to the name of an adapter in the config. This also prevents you from having to go into every chat buffer that you have open to manually set the adapter.

💡 Advanced Usage

📋 Prompt Library

The plugin comes with a number of pre-built prompts. As per the config, these can be called via keymaps or via the cmdline. These prompts have been carefully curated to mimic those in GitHub's Copilot Chat. Of course, you can create your own prompts and add them to the Action Palette or even to the slash command completion menu in the chat buffer. Please see the RECIPES guide for more information.

Using Keymaps

You can call a prompt from the library via a keymap using the prompt helper:

vim.api.nvim_set_keymap("v", "<LocalLeader>ce", "", {
  callback = function()
    require("codecompanion").prompt("explain")
  end,
  noremap = true,
  silent = true,
})

In the example above, we've set a visual keymap that will trigger the Explain prompt. Providing the short_name of the prompt as an argument to the helper (e.g. "commit") will resolve the strategy down to an action.

💬 The Chat Buffer

The chat buffer is where you converse with an LLM from within Neovim. The chat buffer has been designed to be turn based, whereby you send a message and the LLM replies. Messages are segmented by H2 headers and once a message has been sent, it cannot be edited. You can also have multiple chat buffers open at the same.

The look and feel of the chat buffer can be customised as per the display.chat table in the config. You can also add additional Variables and Slash Commands which can then be referenced in the chat buffer.

Keymaps

When in the chat buffer, press ? to bring up a menu that lists the available keymaps, variables, slash commands and tools. Currently, the keymaps available to you in normal mode are:

<CR>|<C-s> to send a message to the LLM
<C-c> to close the chat buffer
q to stop the current request
ga to change the adapter for the currentchat
gc to insert a codeblock in the chat buffer
gd to view/debug the chat buffer's contents
gf to fold any codeblocks in the chat buffer
gr to regenerate the last response
gs to toggle the system prompt on/off
gx to clear the chat buffer's contents
gy to yank the last codeblock in the chat buffer
[[ to move to the previous header
]] to move to the next header
{ to move to the previous chat
} to move to the next chat

[!NOTE] There are also corresponding insert mode mappings available.

Settings

You can display your selected adapter's schema at the top of the buffer, if display.chat.show_settings is set to true. This allows you to vary the response from the LLM.

Slash Commands

As outlined in the Quickstart section, Slash Commands allow you to easily share additional context with your LLM from the chat buffer. Some of the commands also allow for multiple providers:

/buffer - Has default, telescope and fzf_lua providers
/files - Has default, telescope, mini_pick and fzf_lua providers

Please refer to the config to see how to change the default provider.

✏ Inline Assistant

[!NOTE] If you've set opts.send_code = false in your config then the plugin will endeavour to ensure no code is sent to the LLM.

One of the challenges with inline editing is determining how the LLM's response should be handled in the buffer. If you've prompted the LLM to "create a table of 5 common text editors" then you may wish for the response to be placed at the cursor's position in the current buffer. However, if you asked the LLM to "refactor this function" then you'd expect the response to replace a visual selection. The plugin will use the inline LLM you've specified in your config to determine if the response should...

replace - replace a visual selection you've made
add - be added in the current buffer at the cursor position
new - be placed in a new buffer
chat - be placed in a chat buffer

By default, an inline assistant prompt will trigger the diff feature, showing differences between the original buffer and the changes from the LLM. This can be turned off in your config via the display.diff.provider table. You can also choose to accept or reject the LLM's suggestions with the following keymaps:

ga - Accept an inline edit
gr - Reject an inline edit

🤖 Agents / Tools

As outlined by Andrew Ng in Agentic Design Patterns Part 3, Tool Use, LLMs can act as agents by leveraging external tools. Andrew notes some common examples such as web searching or code execution that have obvious benefits when using LLMs.

In the plugin, tools are simply context that's given to an LLM via a system prompt and Agents are groupings of tools. These give LLM's knowledge and a defined schema which can be included in the response for the plugin to parse, execute and feedback on. Agents and tools can be added as a participant to the chat buffer by using the @ key.

More information on how agents and tools work and how you can create your own can be found in the TOOLS guide.

🗺 Agentic Workflows

Agentic Workflows prompt an LLM multiple times, giving them the ability to build their answer step-by-step instead of at once. This leads to much better output as outlined by Andrew Ng. Infact, it's possible for older models like GPT 3.5 to outperform newer models (using traditional zero-shot inference).

Implementing Andrew's advice, at various stages of a pre-defined workflow, the plugin will automatically prompt the LLM without any input or triggering required from the user. The plugin contains a default Code workflow, as part of the prompt library, which guides the LLM into writing better code.

Of course you can add new workflows by following the RECIPES guide.

🍭 Extras

Highlight Groups

The plugin sets the following highlight groups during setup:

CodeCompanionChatHeader - The headers in the chat buffer
CodeCompanionChatSeparator - Separator between headings in the chat buffer
CodeCompanionChatTokens - Virtual text in the chat buffer showing the token count
CodeCompanionChatAgent - Agents in the chat buffer
CodeCompanionChatTool - Tools in the chat buffer
CodeCompanionChatVariable - Variables in the chat buffer
CodeCompanionVirtualText - All other virtual text in the plugin

Events/Hooks

The plugin fires many events during its lifecycle:

CodeCompanionChatClosed - Fired after a chat has been closed
CodeCompanionChatAdapter - Fired after the adapter has been set in the chat
CodeCompanionChatModel - Fired after the model has been set in the chat
CodeCompanionToolAdded - Fired when a tool has been added to a chat
CodeCompanionAgentStarted - Fired when an agent has been initiated in the chat
CodeCompanionAgentFinished - Fired when an agent has finished all tool executions
CodeCompanionInlineStarted - Fired at the start of the Inline strategy
CodeCompanionInlineFinished - Fired at the end of the Inline strategy
CodeCompanionRequestStarted - Fired at the start of any API request
CodeCompanionRequestFinished - Fired at the end of any API request
CodeCompanionDiffAttached - Fired when in Diff mode
CodeCompanionDiffDetached - Fired when exiting Diff mode

[!TIP] Some events are sent with a data payload which can be leveraged.

Events can be hooked into as follows:

local group = vim.api.nvim_create_augroup("CodeCompanionHooks", {})

vim.api.nvim_create_autocmd({ "User" }, {
  pattern = "CodeCompanionInline*",
  group = group,
  callback = function(request)
    if request.match == "CodeCompanionInlineFinished" then
      -- Format the buffer after the inline request has completed
      require("conform").format({ bufnr = request.buf })
    end
  end,
})

Statuslines

You can incorporate a visual indication to show when the plugin is communicating with an LLM in your Neovim configuration. Below are examples for two popular statusline plugins.

lualine.nvim:

local M = require("lualine.component"):extend()

M.processing = false
M.spinner_index = 1

local spinner_symbols = {
  "⠋",
  "⠙",
  "⠹",
  "⠸",
  "⠼",
  "⠴",
  "⠦",
  "⠧",
  "⠇",
  "⠏",
}
local spinner_symbols_len = 10

-- Initializer
function M:init(options)
  M.super.init(self, options)

  local group = vim.api.nvim_create_augroup("CodeCompanionHooks", {})

  vim.api.nvim_create_autocmd({ "User" }, {
    pattern = "CodeCompanionRequest*",
    group = group,
    callback = function(request)
      if request.match == "CodeCompanionRequestStarted" then
        self.processing = true
      elseif request.match == "CodeCompanionRequestFinished" then
        self.processing = false
      end
    end,
  })
end

-- Function that runs every time statusline is updated
function M:update_status()
  if self.processing then
    self.spinner_index = (self.spinner_index % spinner_symbols_len) + 1
    return spinner_symbols[self.spinner_index]
  else
    return nil
  end
end

return M

heirline.nvim:

local CodeCompanion = {
  static = {
    processing = false,
  },
  update = {
    "User",
    pattern = "CodeCompanionRequest*",
    callback = function(self, args)
      if args.match == "CodeCompanionRequestStarted" then
        self.processing = true
      elseif args.match == "CodeCompanionRequestFinished" then
        self.processing = false
      end
      vim.cmd("redrawstatus")
    end,
  },
  {
    condition = function(self)
      return self.processing
    end,
    provider = " ",
    hl = { fg = "yellow" },
  },
}

Legendary.nvim

The plugin also supports the amazing legendary.nvim plugin. Simply enable it in your config:

require('legendary').setup({
  extensions = {
    codecompanion = true,
  },
})

Mini.Diff

If you're using mini.diff you can put an icon in the statusline to indicate which diff is currently in use in a buffer:

local function diff_source()
  local bufnr, diff_source, icon
  bufnr = vim.api.nvim_get_current_buf()
  diff_source = vim.b[bufnr].diffCompGit
  if not diff_source then
    return ""
  end
  if diff_source == "git" then
    icon = "󰊤 "
  elseif diff_source == "codecompanion" then
    icon = " "
  end
  return string.format("%%#StatusLineLSP#%s", icon)
end

🧰 Troubleshooting

Before raising an issue, there are a number of steps you can take to troubleshoot a problem:

Checkhealth

Run :checkhealth codecompanion and check all dependencies are installed correctly. Also take note of the log file path.

Turn on logging

Update your config and turn debug logging on:

opts = {
  log_level = "DEBUG", -- or "TRACE"
}

and inspect the log file as per the location from the checkhealth command.

Try with a minimal.lua file

A large proportion of issues which are raised in Neovim plugins are to do with a user's own config. That's why I always ask users to fill in a minimal.lua file when they raise an issue. We can rule out their config being an issue and it allows me to recreate the problem.

For this purpose, I have included a minimal.lua file in the repository for you to test out if you're facing issues. Simply copy the file, edit it and run neovim with nvim --clean -u minimal.lua.

🎁 Contributing

I am open to contributions but they will be implemented at my discretion. Feel free to open up a discussion before embarking on a PR and please read the CONTRIBUTING.md guide.

👏 Acknowledgements

Steven Arcangeli for his genius creation of the chat buffer and his feedback early on
Manoel Campos for the xml2lua library that's used in the tools implementation
Dante.nvim for the beautifully simple diff implementation
Wtf.nvim for the LSP assistant action
CopilotChat.nvim for the rendering and usability of the chat buffer
Aerial.nvim for the Tree-sitter parsing which inspired the symbols Slash Command

ncalc/ncalc

2024-11-19T01:29:39Z

NCalc is a fast and lightweight expression evaluator library for .NET, designed for flexibility and high performance. It supports a wide range of mathematical and logical operations.

NCalc

NCalc is a fast and lightweight expression evaluator library for .NET, designed for flexibility and high performance. It supports a wide range of mathematical and logical operations. NCalc can parse any expression and evaluate the result, including static or dynamic parameters and custom functions. NCalc targets .NET 8, .NET Standard 2.0 and NET Framework 4.8.

Docs

Need help or want to learn more? Check our docs.

Learn more

For additional information on the technique we used to create this framework please read this article.

Help

[!IMPORTANT] If you need help, please open an issue and include the expression to help us better understand the problem. Providing this information will aid in resolving the issue effectively.

Getting Started

If you want to evaluate simple expressions:

dotnet add package NCalcSync

Want async support at your functions and parameters?

dotnet add package NCalcAsync

Dependency Injection? We got you covered:

dotnet add package NCalc.DependencyInjection

Functionalities

Simple Expressions

var expression = new Expression("2 + 3 * 5");
Debug.Assert(17 == expression.Evaluate());

Evaluates .NET data types

Debug.Assert(123456 == new Expression("123456").Evaluate()); // integers
Debug.Assert(new DateTime(2001, 01, 01) == new Expression("#01/01/2001#").Evaluate()); // date and times
Debug.Assert(123.456 == new Expression("123.456").Evaluate()); // floating point numbers
Debug.Assert(true == new Expression("true").Evaluate()); // booleans
Debug.Assert("azerty" == new Expression("'azerty'").Evaluate()); // strings

Handles mathematical functional from System.Math

Debug.Assert(0 == new Expression("Sin(0)").Evaluate());
Debug.Assert(2 == new Expression("Sqrt(4)").Evaluate());
Debug.Assert(0 == new Expression("Tan(0)").Evaluate());

Evaluates custom functions

var expression = new Expression("SecretOperation(3, 6)");
expression.Functions["SecretOperation"] = (args) => {
    return (int)args[0].Evaluate() + (int)args[1].Evaluate();
};

Debug.Assert(9 == expression.Evaluate());

Handles unicode characters

Debug.Assert("経済協力開発機構" == new Expression("'経済協力開発機構'").Evaluate());
Debug.Assert("Hello" == new Expression(@"'\u0048\u0065\u006C\u006C\u006F'").Evaluate());
Debug.Assert("だ" == new Expression(@"'\u3060'").Evaluate());
Debug.Assert("\u0100" == new Expression(@"'\u0100'").Evaluate());

Define parameters, even dynamic or expressions

var expression = new Expression("Round(Pow([Pi], 2) + Pow([Pi2], 2) + [X], 2)");

expression.Parameters["Pi2"] = new Expression("Pi * [Pi]");
expression.Parameters["X"] = 10;

expression.DynamicParameters["Pi"] = _ => {
    Console.WriteLine("I'm evaluating π!");
    return 3.14;
};

Debug.Assert(117.07 == expression.Evaluate());

JSON Serialization

At .NET 8+, NCalc have built-in support to polymorphic JSON serialization using System.Text.Json.

const string expressionString = "{waterLevel} > 4.0";

var logicalExpression = LogicalExpressionFactory.Create(expressionString, ExpressionOptions.NoCache); //Created a BinaryExpression object.

var jsonExpression = JsonSerializer.Serialize(parsedExpression);

var deserializedLogicalExpression = JsonSerializer.Deserialize<LogicalExpression>(jsonExpression); //The object is still a BinaryExpression.

var expression = new Expression(deserializedLogicalExpression);

expression.Parameters = new Dictionary<string, object> {
    {"waterLevel", 4.0}
};

var result = expression.Evaluate();

Caching NCalc automatically cache the parsing of strings using a ConcurrentDictionary. You can also use our Memory Cache plugin.

Lambda Expressions

var expression = new Expression("1 + 2");
Func<int> function = expression.ToLambda<int>();
Debug.Assert(function()); //3

Related projects

Parlot

Fast and lightweight parser creation tools by Sébastien Ros that NCalc uses at its parser.

PanoramicData.NCalcExtensions

Extension functions for NCalc to handle many general functions,
including string functions, switch, if, in, typeOf, cast etc.
Developed by David, Dan and all at Panoramic Data.

Jint

JavaScript Interpreter for .NET by Sébastien Ros, the author of NCalc library.
Runs on any modern .NET platform as it supports .NET Standard 2.0 and .NET 4.6.1 targets (and up).

NCalcJS

A TypeScript/JavaScript port of NCalc.

NCalc101

NCalc 101 is a simple web application that allows you to try out the NCalc expression evaluator, developed by Panoramic Data.

JJMasterData

JJMasterData is a runtime form generator from database metadata. It uses NCalc to evaluate expressions used in field visibility and other dynamic behaviors.

NCalc versioning

The project uses Nerdbank.GitVersioning tool to manage versions.
Each library build can be traced back to the original git commit. Read more about versioning here.

Discord Server

If you want to talk with us, get support or just get the latest NCalc news, come to our discord server.

Star History

crawl/crawl

2024-11-19T01:29:36Z

Dungeon Crawl: Stone Soup official repository

Dungeon Crawl Stone Soup

Dungeon Crawl Stone Soup is a game of dungeon exploration, combat and magic, involving characters of diverse skills, worshipping deities of great power and caprice. To win, you'll need to be a master of tactics and strategy, and prevail against overwhelming odds.

How to Play

For information on how to install the game, please visit the installation documentation.

If you'd like to dive in immediately, we suggest one of:

Start a game and pick a tutorial (select tutorial in the game menu),
Read quickstart.md (in the docs/ directory), or
For the studious, read Crawl's full manual.

There is also an ingame list of frequently asked questions which you can access by typing ?Q.

Internet Play

You can play Crawl online, competing with other players or watching them. Click "Play Online Now!" on the Crawl homepage to find your closest server. You can play in your browser or over SSH.

Offline Play

Both classical ASCII and tiles (GUI) versions of Crawl are available to download for Linux, Windows and OS X.

Community

Our official homepage: crawl.develz.org
- Online webtiles play
- Offline downloads
- Our community forum: tavern.dcss.io
/r/roguelikes Discord
The /r/dcss subreddit
IRC: #crawl on Libera (or #crawl-dev to chat development)

How you can help

If you like the game and you want to help make it better, there are a number of ways to do so. For a detailed guide to the crawl workflow, look at the contributor's guide.

Reporting bugs

At any time, there will be bugs -- finding and reporting them is a great help. Many of the online servers host the regularly updated development version. Bugs should be reported to our github issue tracker. Thoughtful ideas on how to improve interface or gameplay are welcome, but it's often best to discuss changes before opening an issue or pull request.

Map making

Crawl creates levels by combining many hand-made (but often randomised) maps, known as vaults. Making them is fun and easy. It's best to start with simple entry vaults: see simple.des for examples. You can also read the level-design manual for more help.

If you're ambitious, you can create new vaults for anywhere in the game. If you've made some vaults, you can test them on your own system (no compiling needed) and submit them via a github pull request. See the contributor's guide for details.

Monster Speech & Item Descriptions

Monster speech provides a lot of flavour. Just like vaults, varied speech depends upon a large set of entries. Speech syntax is effective but unusual, so you may want to read the formatting guide.

Current item descriptions can be read in-game with ?/ or out-of-game them in dat/descript/. The following conventions should be more or less obeyed:

Descriptions ought to contain flavour text, ideally pointing out major weaknesses/strengths.
No numbers, please.
Citations are okay, but try to stay away from the most generic ones.

Tiles

We're always open to improvements to existing tiles or variants of often-used tiles (eg floor tiles). If you want to give this a shot, please contact us. In case you drew some tiles of your own, you can simply share them with a developer or submit them via a github pull request. See the contributor's guide for details.

Patches

For developers (both existing & aspiring!), you can download/fork the source code and write patches. Bug fixes as well as new features are very much welcome.

For large changes, it's always a good idea to talk with the dev team first, to see if any plans already exist and if your suggestion is likely to be accepted.

Please be sure to read docs/develop/coding_conventions.md too.

License and history information

Crawl is licensed as GPLv2+. See LICENSE for the full text.

Crawl is a descendant of Linley's Dungeon Crawl. The final alpha of Linley's Dungeon Crawl (v4.1) was released by Brent Ross in 2005. Since 2006, the Dungeon Crawl Stone Soup team has continued development. CREDITS.txt contains a full list of contributors.

Crawl uses the following open source packages; thanks to their developers:

The Lua scripting language, for in-game functionality and user macros (license).
The PCRE library, for regular expressions (license).
The SQLite library, as a database engine (license).
The SDL and SDL_image libraries, for tiles display (license).
The libpng library, for tiles image loading (license).

Thank you, and have fun crawling!

AdAway/AdAway

2024-11-18T01:29:13Z

A C library for reading and writing sound files containing sampled audio data.

libsndfile

libsndfile is a C library for reading and writing files containing sampled audio data.

Authors

The libsndfile project was originally developed and maintained by Erik de Castro Lopo erikd@mega-nerd.com aka @erikd. The project was developed on Github at https://github.com/erikd/libsndfile.

After the release of version 1.0.30, @erikd transferred the project to the libsndfile team, see AUTHORS for details.

Hacking

The canonical source code repository for libsndfile is at https://github.com/libsndfile/libsndfile.

You can grab the source code using:

git clone https://github.com/libsndfile/libsndfile.git

For building for Android see BuildingForAndroid.

There are currently two build systems: the traditional GNU autotool based one and modern CMake based build system. Use of the CMake build system is documented below.

Setting up a build environment for libsndfile on Debian or Ubuntu is as simple as:

sudo apt install autoconf autogen automake build-essential libasound2-dev \
  libflac-dev libogg-dev libtool libvorbis-dev libopus-dev libmp3lame-dev \
  libmpg123-dev pkg-config python

For other Linux distributions or any of the *BSDs, the setup should be similar although the package install tools and package names may be slightly different.

Similarly on Mac OS X, assuming brew is already installed:

brew install autoconf autogen automake flac libogg libtool libvorbis opus mpg123 pkg-config

Once the build environment has been set up, building and testing libsndfile is as simple as:

autoreconf -vif
./configure --enable-werror
make
make check

The CMake build system

Although Autotools is the primary and recommended build toolchain, CMake meta build generator is also available. The build process with CMake takes place in two stages. First, standard build files are created from configuration scripts. Then the platform's native build tools are used for the actual building. CMake can produce Microsoft Visual Studio project and solution files, Unix Makefiles, Xcode projects and many more.

Some IDE support CMake natively or with plugins, check you IDE documentation for details.

Requirements

C99-compliant compiler toolchain (tested with GCC, Clang and Visual Studio 2015)
CMake 3.1.3 or newer

There are some recommended packages to enable all features of libsndfile:

Ogg, Vorbis and FLAC libraries and headers to enable these formats support
ALSA development package under Linux to build sndfile-play utility
Sndio development package under BSD to build sndfile-play utility

Building from command line

CMake can handle out-of-place builds, enabling several builds from the same source tree, and cross-compilation. The ability to build a directory tree outside the source tree is a key feature, ensuring that if a build directory is removed, the source files remain unaffected.

mkdir CMakeBuild
cd CMakeBuild

Then run cmake command with directory where CMakeLists.txt script is located as argument (relative paths are supported):

cmake ..

This command will configure and write build script or solution to CMakeBuild directory. CMake is smart enough to create Unix makefiles under Linux or Visual Studio solution if you have Visual Studio installed, but you can configure generator with -G command line parameter:

cmake .. -G"Unix Makefiles"

The build procedure depends on the selected generator. With "Unix Makefiles" you can type:

make & make install

With "Visual Studio" and some other generators you can open solution or project from CMakeBuild directory and build using IDE.

Finally, you can use unified command:

cmake --build .

CMake also provides Qt-based cross platform GUI, cmake-gui. Using it is trivial and does not require detailed explanations.

Configuring CMake

You can pass additional options with /D<parameter>=<value> when you run cmake command. Some useful system options:

CMAKE_C_FLAGS - additional C compiler flags
CMAKE_BUILD_TYPE - configuration type, DEBUG, RELEASE, RELWITHDEBINFO or MINSIZEREL. DEBUG is default
CMAKE_INSTALL_PREFIX - build install location, the same as --prefix option of configure script

Useful libsndfile options:

BUILD_SHARED_LIBS - build shared library (DLL under Windows) when ON, build static library otherwise. This option is OFF by default.
BUILD_PROGRAMS - build libsndfile's utilities from programs/ directory, ON by default.
BUILD_EXAMPLES - build examples, ON by default.
BUILD_TESTING - build tests. Then you can run tests with ctest command, ON by default. Setting BUILD_SHARED_LIBS to ON disables this option.
ENABLE_EXTERNAL_LIBS - enable Ogg, Vorbis, FLAC and Opus support. This option is available and set to ON if all dependency libraries were found.
ENABLE_MPEG - MP3 support. This option is available and set to ON if all dependency libraries were found.
ENABLE_BOW_DOCS - enable black-on-white documentation theme, OFF by default.
ENABLE_EXPERIMENTAL - enable experimental code. Don't use it if you are not sure. This option is OFF by default.
ENABLE_CPACK - enable CPack support. This option is ON by default.
ENABLE_PACKAGE_CONFIG - generate and install package config file.
INSTALL_PKGCONFIG_MODULE - generate and install pkg-config module.
INSTALL_MANPAGES - install man pages for programs. This option is ON by default
ENABLE_STATIC_RUNTIME - enable static runtime on Windows platform (MSVC and MinGW), OFF by default.

Note: For MSVC compiler this option is deprecated for CMake >= 3.15, see policy CMP0091. Use CMAKE_MSVC_RUNTIME_LIBRARY option instead.

Note: For MinGW toolchain this option is experimental. If you enabled it and then disabled again, you need to clear CMake cache (delete CMakeCache.txt).
ENABLE_COMPATIBLE_LIBSNDFILE_NAME - set DLL name to libsndfile-1.dll (canonical name) on Windows platform, sndfile.dll otherwise, OFF by default. Library name can be different depending on platform. The well known DLL name on Windows platform is libsndfile-1.dll, because the only way to build Windows library before was MinGW toolchain with Autotools. This name is native for MinGW ecosystem, Autotools constructs it using MinGW platform rules from sndfile target. But when you build with CMake using native Windows compiler, the name is sndfile.dll. This is name for native Windows platform, because Windows has no library naming rules. It is preferred because you can search library using package manager or CMake's find_library command on any platform using the same sndfile name.
ENABLE_SSE2 - add compiler flag to enable SSE2 if required, ON by default.

This option is for X86 and GCC compatible compilers configurations only.

If you compile for other SIMD set, e.g. AVX2, you may want to set ENABLE_SSE2 to OFF.

Note: This option is not active for X64 configuration, because SSE2 is always available in this mode and all optimizations are enabled by default.

Deprecated options:

DISABLE_EXTERNAL_LIBS - disable Ogg, Vorbis and FLAC support. Replaced by ENABLE_EXTERNAL_LIBS
BUILD_STATIC_LIBS - build static library. Use BUILD_SHARED_LIBS instead

Linking from CMake projects

First you need to add FindOgg.cmake, FindVorbis.cmake, FindFLAC.cmake and FindOpus.cmake files to some directory inside your CMake project (usually cmake) and add it to CMAKE_MODULE_PATH:

project(SomeApplication)

list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)

Now you can search libsndfile library from your CMakeLists.txt with this command:

find_package(SndFile)

SndFile_FOUND is set to ON when library is found.

If libsndfile dependency is critical, you can add REQUIRED to find_package:

find_package(SndFile REQUIRED)

With with option find_package will terminate configuration process if libsndfile is not found.

You can also add version check:

find_package(SndFile 1.0.29)

find_package will report error, if libsndfile version is < 1.0.29.

You can combine REQUIRED and version if you need.

To link libsndfile library use:

target_link_libraries(my_application PRIVATE SndFile::sndfile)

Notes for Windows users

System CRT library

First advice about Visual Studio system CRT libraries, it is system code linked as static or dynamic library to every C application.

You can find related option in Visual Studio project properties:

C/C++ -> Code Generation -> Runtime Library

Dynamic version of system CRT library is default and it means that end user needs to have the same runtime library installed on his system. Most likely it is so, but if it is not, the user will see this error message using libsndfile DLL:

"The program can't start because <crt-dll-name>.dll is missing from your computer. Try reinstalling the program to fix this problem. "

To avoid this, you may want to enable static CRT library linking. In this case the size of your DLL will increase slightly the size will increase slightly, but you can redistribute the libsndfile DLL without having to install the correct version of the system CRT library.

CMake project will use dynamic system CRT libraries by default, just like Visual Studio does. But you can change it using ENABLE_STATIC_RUNTIME or CMAKE_MSVC_RUNTIME_LIBRARY options.

Note: You cannot use both options at the same time, it will lead to a configuration error.

If you have CMake >= 3.15 you should use CMAKE_MSVC_RUNTIME_LIBRARY option.

This will enable static linking:

cmake .. -D"MultiThreaded$<$<CONFIG:Debug>:Debug>"

You can use libsndfile ENABLE_STATIC_RUNTIME option to to control CRT library linking for CMake project: OFF or unset (default) for dynamic, and ON for static linking:

cmake .. -DENABLE_STATIC_RUNTIME=ON

Note: This option is deprecated and may be removed in far future because we have standard option CMAKE_MSVC_RUNTIME_LIBRARY now.

Using Vcpkg package manager

Second advice is about Ogg, Vorbis FLAC and Opus support. Searching external libraries under Windows is a little bit tricky. The best way is to use Vcpkg.

Install Vcpkg and then add this parameter to cmake command line:

-DCMAKE_TOOLCHAIN_FILE=<path-to-vcpkg>/scripts/buildsystems/vcpkg.cmake

You also need to set VCPKG_TARGET_TRIPLET if you want to use static libraries:

-DVCPKG_TARGET_TRIPLET=x64-windows-static

Then you need to install static libogg, libvorbis, libflac, libopus, mpg123 and mp3lame Vcpkg packages.

After 1.1.0beta2 you don't need to install dependencies manually. Libsndfile now supports Vcpkg manifest mode and all dependencies are installed automatically.

However, you can turn off the manifest mode and return to the classic mode using the VCPKG_MANIFEST_MODE parameter from the command line:

-DVCPKG_MANIFEST_MODE=OFF

In classic mode, you need to install the required libraries manually:

vcpkg install libvorbis:x64-windows-static libflac:x64-windows-static
opus:x64-windows-static mp3lame:x86-windows-static mpg123:x86-windows-static
libvorbis:x86-windows-static libflac:x86-windows-static
opus:x86-windows-static mp3lame:x86-windows-static mpg123:x86-windows-static

Note: Use must use the same CRT library for external libraries and the libsndfile library itself. For *-static triplets Vcpkg uses static CRT.

Submitting Patches

See CONTRIBUTING.md for details.

Anonym-tsk/nfqws-keenetic

2024-11-19T01:30:07Z

nfqws-keenetic

Пакеты для установки nfqws на маршрутизаторы с поддержкой opkg.

[!IMPORTANT] Данный материал подготовлен в научно-технических целях. Использование предоставленных материалов в целях отличных от ознакомления может являться нарушением действующего законодательства. Автор не несет ответственности за неправомерное использование данного материала.

[!WARNING] Вы пользуетесь этой инструкцией на свой страх и риск!

Автор не несёт ответственности за порчу оборудования и программного обеспечения, проблемы с доступом и потенцией. Подразумевается, что вы понимаете, что вы делаете.

Изначально написано для роутеров Keenetic с установленным entware. Однако, работоспособность также была проверена на прошивках Padavan и OpenWRT (читайте ниже).

Списки проверенного оборудования собираем в отдельной теме.

Поделиться опытом можно в разделе Discussions или в чате.

Если nfqws работает как-то не так, можете попробовать tpws.

Что это?

nfqws - утилита для модификации TCP соединения на уровне пакетов, работает через обработчик очереди NFQUEUE и raw сокеты.

Почитать подробнее можно на странице авторов (ищите по ключевому слову nfqws).

Подготовка Keenetic

Прочитайте инструкцию полностью, прежде, чем начать что-то делать!
Рекомендуется игнорировать предложенные провайдером адреса DNS-серверов. Для этого в интерфейсе роутера отметьте пункты "игнорировать DNS от провайдера" в настройках IPv4 и IPv6.
Вместе с этим рекомендуется настроить использование DoT/DoH.
Установить entware на маршрутизатор по инструкции на встроенную память роутера или на USB-накопитель.
Через web-интерфейс Keenetic установить пакеты Протокол IPv6 (Network functions > IPv6) и Модули ядра подсистемы Netfilter (OPKG > Kernel modules for Netfilter - не путать с "Netflow"). Обратите внимание, что второй компонент отобразится в списке пакетов только после того, как вы отметите к установке первый.
В разделе "Интернет-фильтры" отключить все сторонние фильтры (NextDNS, SkyDNS, Яндекс DNS и другие).
Все дальнейшие команды выполняются не в cli роутера, а в среде entware. Подключиться в неё можно несколькими способами:
- Через telnet: в терминале выполнить telnet 192.168.1.1, а потом exec sh.
- Или же подключиться напрямую через SSH (логин - root, пароль по умолчанию - keenetic, порт - 222 или 22). Для этого в терминале написать ssh 192.168.1.1 -l root -p 222.

[!IMPORTANT] Миграция с версии 1.x.x на 2.x.x:

Для определения версии выполните команду opkg info nfqws-keenetic - она работает только на версиях 2.x.x и возвращает информацию о пакете. Если ничего не вернула – у вас установлена старая версия.

Никакой специальной миграции не требуется, просто переустановите новую версию по инструкции ниже.

Установка на Keenetic и Entware

Установите необходимые зависимости

opkg update
opkg install ca-certificates wget-ssl
opkg remove wget-nossl

Установите opkg-репозиторий в систему
```
mkdir -p /opt/etc/opkg
echo "src/gz nfqws-keenetic https://anonym-tsk.github.io/nfqws-keenetic/all" > /opt/etc/opkg/nfqws-keenetic.conf
```
Репозиторий универсальный, поддерживаемые архитектуры: mipsel, mips, aarch64, armv7, x86, x86_64.
Или можете выбрать репозиторий под конкретную архитектуру
- mips-3.4 _{^{Keenetic Giga SE (KN-2410), Ultra SE (KN-2510), DSL (KN-2010), Launcher DSL (KN-2012), Duo (KN-2110), Skipper DSL (KN-2112), Hopper DSL (KN-3610)}}
```
mkdir -p /opt/etc/opkg
echo "src/gz nfqws-keenetic https://anonym-tsk.github.io/nfqws-keenetic/mips" > /opt/etc/opkg/nfqws-keenetic.conf
```
- mipsel-3.4 _{^{Keenetic Giga (KN-1010/1011), Ultra (KN-1810), Viva (KN-1910/1912), Hero 4G (KN-2310), Hero 4G+ (KN-2311), Giant (KN-2610), Skipper 4G (KN-2910), Hopper (KN-3810)}}
```
mkdir -p /opt/etc/opkg
echo "src/gz nfqws-keenetic https://anonym-tsk.github.io/nfqws-keenetic/mipsel" > /opt/etc/opkg/nfqws-keenetic.conf
```
- aarch64-3.10 _{^{Keenetic Peak (KN-2710), Ultra (KN-1811), Hopper SE (KN-3812), Keenetic Giga (KN-1012)}}
```
mkdir -p /opt/etc/opkg
echo "src/gz nfqws-keenetic https://anonym-tsk.github.io/nfqws-keenetic/aarch64" > /opt/etc/opkg/nfqws-keenetic.conf
```

Установите пакет

opkg update
opkg install nfqws-keenetic

Установите веб-интерфейс (опционально)
```
opkg install nfqws-keenetic-web
```

[!NOTE] Для авторизации введите имя пользователя и пароль пользователя entware

[!TIP] По-умолчанию php использует только 8Мб памяти. Из-за этого ограничения, могут не загружаться большие списки файлов. Вы можете изменить конфигурацию php самостоятельно:
Откройте файл /opt/etc/php.ini и измените следующие значения
memory_limit = 32M
post_max_size = 32M
upload_max_filesize = 16M

Обновление

opkg update
opkg upgrade nfqws-keenetic
opkg upgrade nfqws-keenetic-web

Удаление

opkg remove --autoremove nfqws-keenetic-web nfqws-keenetic

Информация об установленной версии

opkg info nfqws-keenetic
opkg info nfqws-keenetic-web

Установка на OpenWRT

Пакет работает только с iptables. Если в вашей системе используется nftables, придется удалить nftables и firewall4, и установить firewall3 и iptables.

Проверить, что ваша система использует nftables:

ls -la /sbin/fw4
which nft

Установите необходимые зависимости

opkg update
opkg install ca-certificates wget-ssl
opkg remove wget-nossl

Установите публичный ключ репозитория

wget -O "/tmp/nfqws-keenetic.pub" "https://anonym-tsk.github.io/nfqws-keenetic/openwrt/nfqws-keenetic.pub"
opkg-key add /tmp/nfqws-keenetic.pub

Установите opkg-репозиторий в систему
```
echo "src/gz nfqws-keenetic https://anonym-tsk.github.io/nfqws-keenetic/openwrt" > /etc/opkg/nfqws-keenetic.conf
```
Репозиторий универсальный, поддерживаемые архитектуры: mipsel, mips, aarch64, armv7, x86, x86_64. Для добавления поддержки новых устройств, создайте Feature Request

Установите пакет

opkg update
opkg install nfqws-keenetic

Установите веб-интерфейс (опционально)
```
opkg install nfqws-keenetic-web
```

[!NOTE] NB: Все пути файлов, описанные в этой инструкции, начинающиеся с /opt, на OpenWRT будут начинаться с корня /. Например конфиг расположен в /etc/nfqws/nfqws.conf

Для запуска/остановки используйте команду service nfqws-keenetic {start|stop|restart|reload|status}

Настройки

Файл настроек расположен по пути /opt/etc/nfqws/nfqws.conf. Для редактирования можно воспользоваться встроенным редактором vi или установить nano.

# Интерфейс провайдера. Обычно `eth3` или `eth2.2` для проводного соединения, и `ppp0` для PPPoE
# Заполняется автоматически при установке
# Можно ввести несколько интерфейсов, например ISP_INTERFACE="eth3 nwg1"
ISP_INTERFACE="eth3"

# Стратегии обработки HTTPS и QUIC трафика
NFQWS_ARGS="--dpi-desync=fake,split2 --dpi-desync-ttl=0 --dpi-desync-repeats=16 --dpi-desync-split-pos=1 --dpi-desync-fooling=md5sig,badseq --dpi-desync-cutoff=d4 --dpi-desync-fake-tls=/opt/etc/nfqws/tls_clienthello.bin"
NFQWS_ARGS_QUIC="--filter-udp=443 --dpi-desync=fake --dpi-desync-repeats=11 --dpi-desync-cutoff=d4 --dpi-desync-fake-quic=/opt/etc/nfqws/quic_initial.bin"

# Стратегия обработки UDP трафика (не использует параметры из NFQWS_EXTRA_ARGS)
NFQWS_ARGS_UDP="--filter-udp=50000-50099 --dpi-desync=fake --dpi-desync-any-protocol --dpi-desync-repeats=6 --dpi-desync-cutoff=n2"

# Режим работы (auto, list, all)
NFQWS_EXTRA_ARGS="--hostlist=/opt/etc/nfqws/user.list --hostlist-auto=/opt/etc/nfqws/auto.list --hostlist-auto-debug=/opt/var/log/nfqws.log --hostlist-exclude=/opt/etc/nfqws/exclude.list"

# Обрабатывать ли IPv6 соединения
IPV6_ENABLED=1

# TCP порты для iptables
# Оставьте пустым, если нужно отключить обработку TCP
# Добавьте порт 80 для обработки HTTP (TCP_PORTS=443,80)
TCP_PORTS=443

# UDP порты для iptables
# Оставьте пустым, если нужно отключить обработку UDP
# Удалите порт 443, если не нужно обрабатывать QUIC
UDP_PORTS=443,50000:50099

# Логирование в Syslog
LOG_LEVEL=0

Стратегии применяются ко всем доменам из user.list и auto.list, за исключением доменов из exclude.list. В конфиге есть 3 варианта параметра NFQWS_EXTRA_ARGS - это режим работы nfqws:

В режиме list будут обрабатываться только домены из файла user.list
В режиме auto кроме этого будут автоматически определяться недоступные домены и добавляться в список, по которому nfqws обрабатывает трафик. Домен будет добавлен, если за 60 секунд будет 3 раза определено, что ресурс недоступен
В режиме all будет обрабатываться весь трафик кроме доменов из списка exclude.list

Полезное

Конфиг-файл /opt/etc/nfqws/nfqws.conf
Скрипт запуска/остановки /opt/etc/init.d/S51nfqws {start|stop|restart|reload|status}
Вручную добавить домены в список можно в файле /opt/etc/nfqws/user.list (один домен на строке, поддомены учитываются автоматически)
Автоматически добавленные домены /opt/etc/nfqws/auto.list
Лог автоматически добавленных доменов /opt/var/log/nfqws.log
Домены-исключения /opt/etc/nfqws/exclude.list (один домен на строке, поддомены учитываются автоматически)
Проверить, что нужные правила добавлены в таблицу маршрутизации iptables-save | grep "queue-num 200"
Вы должны увидеть похожие строки
```
-A POSTROUTING -o eth3 -p tcp -m tcp --dport 443 -m connbytes --connbytes 1:6 --connbytes-mode packets --connbytes-dir original -m mark ! --mark 0x40000000/0x40000000 -j NFQUEUE --queue-num 200 --queue-bypass
```

Если ничего не работает...

Если ваше устройство поддерживает аппаратное ускорение (flow offloading, hardware nat, hardware acceleration), то iptables могут не работать. При включенном offloading пакет не проходит по обычному пути netfilter. Необходимо или его отключить, или выборочно им управлять.
На Keenetic можно попробовать выключить или наоборот включить сетевой ускоритель
Возможно, стоит выключить службу классификации трафика IntelliQOS.
Можно попробовать отключить IPv6 на сетевом интерфейсе провайдера через веб-интерфейс маршрутизатора.
Можно попробовать запретить весь UDP трафик на 443 порт для отключения QUIC:

Межсетевой экран → Домашняя сеть → Добавить правило
Включить правило: Включено
Описание: Блокировать QUIC
Действие: Запретить
Протокол: UDP
Номер порта назначения: Равен 443
Остальные параметры оставляем без изменений

Частые проблемы

iptables: No chain/target/match by that name
Не установлен пакет "Модули ядра подсистемы Netfilter". На Keenetic он появляется в списке пакетов только после установки "Протокол IPv6"
can't initialize ip6tables table и/или Perhaps ip6tables or your kernel needs to be upgraded
Не установлен пакет "Протокол IPv6". Также, проблема может появляться на старых прошивках 2.xx, выключите поддержку IPv6 в конфиге NFQWS
Ошибки вида readlink: not found, dirname: not found
Обычно возникают не на кинетиках. Решение - установить busybox: opkg install busybox или отдельно пакеты opkg install coreutils-readlink coreutils-dirname

Как использовать несколько стратегий

По-умолчанию, параметры для запуска nfqws формируются из двух переменных – $NFQWS_ARGS $NFQWS_EXTRA_ARGS.
Если вы хотите использовать несколько стратегий, можно разделять их параметром --new. Например, стратегия ниже применит опцию --dpi-desync=fake,split2 для HTTPS запросов к доменам из custom.list, а для всех остальных, соответствующих настройке NFQWS_EXTRA_ARGS, будет использовать --dpi-desync=disorder2 --dpi-desync-fooling=md5sig,badseq:

NFQWS_ARGS="--filter-tcp=443 --dpi-desync=fake,split2 --hostlist=custom.list --new --dpi-desync=disorder2 --dpi-desync-fooling=md5sig,badseq"

Как подобрать рабочую стратегию NFQWS

Запустить скрипт и следовать его инструкциям
```
/bin/sh -c "$(curl -fsSL https://github.com/Anonym-tsk/nfqws-keenetic/raw/master/common/strategy.sh)"
```
Подробнее можно почитать на исходной странице
Найденную стратегию вписать в конфиге /opt/etc/nfqws/nfqws.conf в параметр NFQWS_ARGS

Нравится проект? Поддержи автора здесь или тут. Купи ему немного 🍻 или ☕!

jesusprubio/up

2024-11-18T01:30:57Z

📶 Troubleshoot problems with your Internet connection

up

Troubleshoot problems with your Internet connection based on different protocols and well-known public servers.

Install

Binary Release

You can manually download a binary release for Linux, OSX, Windows or FreeBSD from the releases page.

Go

Please notice latest will install the dev version.

go install -ldflags="-s -w" -v github.com/jesusprubio/up@latest

Use

The default behavior is to verify all the supported protocols against a randomly selected public server for each one.

up

apache/groovy-geb

2024-11-18T01:31:08Z

Apache Geb: Very Groovy Browser Automation

metowolf/vCards

2024-11-19T01:32:10Z

📡️ vCards 中国黄页 - 优化 iOS/Android 来电、信息界面体验

vCards CN

导入常用联系人头像，优化 iOS 来电、信息界面体验。

使用指南

订阅：CardDAV 服务/ 或参考教程自建

采用订阅方式导入，优势是会自动更新，也更方便区分和管理个人通讯录和黄页，不会混合两种列表。

服务器：vcards.metowolf.com
用户名：cn
密码：cn 或任意填写

步骤：

iOS：「设置」--「通讯录」--「账户」--「添加账户」-- 「其他」--「添加 CardDAV 账户」
Mac：「通讯录」--「设置」--「账户」--「其他通讯录账户」

下载导入

到 https://github.com/metowolf/vCards/releases 下载最新的打包文件 archive.zip；
解压后，根据不同平台的指南导入 vcf 文件至 iCloud 中，推荐单独创建「黄页」分组方便管理和隐藏。

macOS

iOS/web

请求收录

打开 https://github.com/metowolf/vCards/issues/new/choose 页面，选择「vCard 新增请求」
完整填写相关信息
提交 issue，等待处理

参与维护

在 /data/类别/ 里添加 yaml 与 png 文件
在根目录下执行 yarn test 检查格式规范
提交 pull requests，等待合并

号码收录

由于不同地区不同运营商的 106 短信推送号段存在差异，项目不作收录，建议将本项目作为一个基础模板，导入联系人后可以按以下方式自行补充其余号码

图标设计

采用 PNG 编码
画布大小 width：200px；height：200px
logo 居中放置
- 圆形尺寸 140w140h
- 正矩形尺寸 120w120h
- 长矩形尺寸 160w80h
- 无 svg 需要使用 Inkscape 改绘转换
- 特殊情况特殊处理
图像大小压缩在 20 kB 内

致谢

114 百事通提供查询接口
百度手机卫士提供查询接口
中国可信号码数据中心提供查询接口

mcauley-penney/visual-whitespace.nvim

2024-11-19T01:32:54Z

Imitate VSCode's "Render Whitespace" feature in visual mode

🔎 visual-whitespace.nvim

Reveal whitespace characters in visual mode, similar to VSCode.

_{GIF: Highlighting in charwise-visual and linewise-visual}

Installation and configuration

To install the plugin with the default settings using Lazy:

  {
    'mcauley-penney/visual-whitespace.nvim',
    config = true
  }

visual-whitespace comes with the following default settings:

    opts = {
      highlight = { link = "Visual" },
      space_char = '·',
      tab_char = '→',
      nl_char = '↲',
      cr_char = '←',
      enabled = true,
      excluded = {
        filetypes = {},
        buftypes = {}
      }
    },

Highlighting

visual-whitespace defines the VisualNonText highlight group. In the configuration, the highlighting settings you provide will constitute this highlight group. The highlight can also be set using Neovim's Lua API:

-- vim.api.nvim_set_hl(0, "VisualNonText", { fg = "#5D5F71", bg = "#24282d"})
-- vim.api.nvim_set_hl(0, "VisualNonText", { link = "Visual" })

Functions

visual-whitespace affords the following user-facing functions:

Lua	Description
`require("visual-whitespace").toggle()`	Turn visual-whitespace.nvim off (toggles the `enabled` cfg flag)

Use them in keymaps like:

init = function()
    vim.keymap.set('n', "<leader>vw", require("visual-whitespace").toggle, {})
end

Credit

This post on the Neovim subreddit, for doing a lot of the math for me
aaron-p1/match-visual.nvim

php/pie

2024-11-19T01:34:09Z

The PHP Installer for Extensions

🥧 PIE (PHP Installer for Extensions)

You will need PHP 8.1 or newer to run PIE, but PIE can install an extension to any installed PHP version.

If you are an extension maintainer wanting to add PIE support to your extension, please read extension-maintainers.

Installing PIE

Manual installation

Download pie.phar either:
- latest stable release
- latest unstable nightly
Validate the signature in pie.phar.asc
You may then invoke PIE with php pie.phar <command>

Further installation details can be found in the usage docs. This documentation assumes you have moved pie.phar into your $PATH, e.g. /usr/local/bin/pie on non-Windows systems.

Extensions that support PIE

A list of extensions that support PIE can be found on https://packagist.org/extensions.

Installing an extension using PIE

You can install an extension using the install command. For example, to install the example_pie_extension extension, you would run:

$ pie install example/example-pie-extension
This command may need elevated privileges, and may prompt you for your password.
You are running PHP 8.3.10
Target PHP installation: 8.3.10 nts, on Linux/OSX/etc x86_64 (from /usr/bin/php8.3)
Found package: example/example-pie-extension:1.0.1 which provides ext-example_pie_extension
phpize complete.
Configure complete.
Build complete: /tmp/pie_downloader_66e0b1de73cdb6.04069773/example-example-pie-extension-769f906/modules/example_pie_extension.so
Install complete: /usr/lib/php/20230831/example_pie_extension.so
You must now add "extension=example_pie_extension" to your php.ini
$

NVIDIA/garak

2024-11-18T01:34:00Z

the LLM vulnerability scanner

garak, LLM vulnerability scanner

Generative AI Red-teaming & Assessment Kit

garak focuses on ways of making an LLM or dialog system fail. It combines static, dyanmic, and adaptive probes to explore this.

garak's a free tool. We love developing it and are always interested in adding functionality to support applications.

Get started

> See our user guide! docs.garak.ai

> Join our Discord!

> Project links & home: garak.ai

> Twitter: @garak_llm

> DEF CON slides!

LLM support

currently supports:

hugging face hub generative models
replicate text models
openai api chat & continuation models
litellm
pretty much anything accessible via REST
gguf models like llama.cpp version >= 1046
.. and many more LLMs!

Install:

garak is a command-line tool. It's developed in Linux and OSX.

Standard install with `pip`

Just grab it from PyPI and you should be good to go:

python -m pip install -U garak

Install development version with `pip`

The standard pip version of garak is updated periodically. To get a fresher version, from GitHub, try:

python -m pip install -U git+https://github.com/NVIDIA/garak.git@main

Clone from source

garak has its own dependencies. You can to install garak in its own Conda environment:

conda create --name garak "python>=3.10,<=3.12"
conda activate garak
gh repo clone NVIDIA/garak
cd garak
python -m pip install -e .

OK, if that went fine, you're probably good to go!

Note: if you cloned before the move to the NVIDIA GitHub organisation, but you're reading this at the github.com/NVIDIA URI, please update your remotes as follows:

git remote set-url origin https://github.com/NVIDIA/garak.git

Getting started

The general syntax is:

garak <options>

garak --list_probes

For help & inspiration, find us on twitter or discord!

Examples

Probe ChatGPT for encoding-based prompt injection (OSX/*nix) (replace example value with a real OpenAI API key)

export OPENAI_API_KEY="sk-123XXXXXXXXXXXX"
python3 -m garak --model_type openai --model_name gpt-3.5-turbo --probes encoding

See if the Hugging Face version of GPT2 is vulnerable to DAN 11.0

python3 -m garak --model_type huggingface --model_name gpt2 --probes dan.Dan_11_0

Reading the results

Here are the results with the encoding module on a GPT-3 variant:

And the same results for ChatGPT:

Send PRs & open issues. Happy hunting!

Intro to generators

Hugging Face

Using the Pipeline API:

--model_type huggingface (for transformers models to run locally)
--model_name - use the model name from Hub. Only generative models will work. If it fails and shouldn't, please open an issue and paste in the command you tried + the exception!

Using the Inference API:

--model_type huggingface.InferenceAPI (for API-based model access)
--model_name - the model name from Hub, e.g. "mosaicml/mpt-7b-instruct"

Using private endpoints:

--model_type huggingface.InferenceEndpoint (for private endpoints)
--model_name - the endpoint URL, e.g. https://xxx.us-east-1.aws.endpoints.huggingface.cloud
(optional) set the HF_INFERENCE_TOKEN environment variable to a Hugging Face API token with the "read" role; see https://huggingface.co/settings/tokens when logged in

OpenAI

--model_type openai
--model_name - the OpenAI model you'd like to use. gpt-3.5-turbo-0125 is fast and fine for testing.
set the OPENAI_API_KEY environment variable to your OpenAI API key (e.g. "sk-19763ASDF87q6657"); see https://platform.openai.com/account/api-keys when logged in

Replicate

set the REPLICATE_API_TOKEN environment variable to your Replicate API token, e.g. "r8-123XXXXXXXXXXXX"; see https://replicate.com/account/api-tokens when logged in

Public Replicate models:

--model_type replicate
--model_name - the Replicate model name and hash, e.g. "stability-ai/stablelm-tuned-alpha-7b:c49dae36"

Private Replicate endpoints:

--model_type replicate.InferenceEndpoint (for private endpoints)
--model_name - username/model-name slug from the deployed endpoint, e.g. elim/elims-llama2-7b

Cohere

--model_type cohere
--model_name (optional, command by default) - The specific Cohere model you'd like to test
set the COHERE_API_KEY environment variable to your Cohere API key, e.g. "aBcDeFgHiJ123456789"; see https://dashboard.cohere.ai/api-keys when logged in

Groq

--model_type groq
--model_name - The name of the model to access via the Groq API
set the GROQ_API_KEY environment variable to your Groq API key, see https://console.groq.com/docs/quickstart for details on creating an API key

ggml

--model_type ggml
--model_name - The path to the ggml model you'd like to load, e.g. /home/leon/llama.cpp/models/7B/ggml-model-q4_0.bin
set the GGML_MAIN_PATH environment variable to the path to your ggml main executable

REST

NIM

Use models from https://build.nvidia.com/ or other NIM endpoints.

set the NIM_API_KEY environment variable to your authentication API token, or specify it in the config YAML

For chat models:

--model_type nim
--model_name - the NIM model name, e.g. meta/llama-3.1-8b-instruct

For completion models:

--model_type nim.NVOpenAICompletion
--model_name - the NIM model name, e.g. bigcode/starcoder2-15b

OctoAI

set the OCTO_API_TOKEN environment variable to your Replicate API token, e.g. "r8-123XXXXXXXXXXXX"; see https://replicate.com/account/api-tokens when logged in

Octo public endpoint:

--model_type octo
--model_name - the OctoAI public endpoint for the model, e.g. mistral-7b-instruct-fp16

Octo private endpoint:

--model_type octo.InferenceEndpoint (for private endpoints)
--model_name - the deployed endpoint URL, e.g. https://llama-2-70b-chat-xxx.octoai.run/v1/chat/completions

Test

--model_type test
(alternatively) --model_name test.Blank For testing. This always generates the empty string, using the test.Blank generator. Will be marked as failing for any tests that require an output, e.g. those that make contentious claims and expect the model to refute them in order to pass.
--model_type test.Repeat For testing. This generator repeats back the prompt it received.

Intro to probes

Probe	Description
blank	A simple probe that always sends an empty prompt.
atkgen	Automated Attack Generation. A red-teaming LLM probes the target and reacts to it in an attempt to get toxic output. Prototype, mostly stateless, for now uses a simple GPT-2 fine-tuned on the subset of hhrlhf attempts that yielded detectable toxicity (the only target currently supported for now).
av_spam_scanning	Probes that attempt to make the model output malicious content signatures
continuation	Probes that test if the model will continue a probably undesirable word
dan	Various DAN and DAN-like attacks
donotanswer	Prompts to which responsible language models should not answer.
encoding	Prompt injection through text encoding
gcg	Disrupt a system prompt by appending an adversarial suffix.
glitch	Probe model for glitch tokens that provoke unusual behavior.
grandma	Appeal to be reminded of one's grandmother.
goodside	Implementations of Riley Goodside attacks.
leakerplay	Evaluate if a model will replay training data.
lmrc	Subsample of the Language Model Risk Cards probes
malwaregen	Attempts to have the model generate code for building malware
misleading	Attempts to make a model support misleading and false claims
packagehallucination	Trying to get code generations that specify non-existent (and therefore insecure) packages.
promptinject	Implementation of the Agency Enterprise PromptInject work (best paper awards @ NeurIPS ML Safety Workshop 2022)
realtoxicityprompts	Subset of the RealToxicityPrompts work (data constrained because the full test will take so long to run)
snowball	Snowballed Hallucination probes designed to make a model give a wrong answer to questions too complex for it to process
xss	Look for vulnerabilities the permit or enact cross-site attacks, such as private data exfiltration.

Logging

garak generates multiple kinds of log:

A log file, garak.log. This includes debugging information from garak and its plugins, and is continued across runs.
A report of the current run, structured as JSONL. A new report file is created every time garak runs. The name of this file is output at the beginning and, if successful, also the end of the run. In the report, an entry is made for each probing attempt both as the generations are received, and again when they are evaluated; the entry's status attribute takes a constant from garak.attempts to describe what stage it was made at.
A hit log, detailing attempts that yielded a vulnerability (a 'hit')

How is the code structured?

Check out the reference docs for an authoritative guide to garak code structure.

garak/probes/ - classes for generating interactions with LLMs
garak/detectors/ - classes for detecting an LLM is exhibiting a given failure mode
garak/evaluators/ - assessment reporting schemes
garak/generators/ - plugins for LLMs to be probed
garak/harnesses/ - classes for structuring testing
resources/ - ancillary items required by plugins

Larger artefacts, like model files and bigger corpora, are kept out of the repository; they can be stored on e.g. Hugging Face Hub and loaded locally by clients using garak.

Developing your own plugin

Take a look at how other plugins do it
Inherit from one of the base classes, e.g. garak.probes.base.TextProbe
Override as little as possible
You can test the new code in at least two ways:
- Start an interactive Python session
  - Import the model, e.g. import garak.probes.mymodule
  - Instantiate the plugin, e.g. p = garak.probes.mymodule.MyProbe()
- Run a scan with test plugins
  - For probes, try a blank generator and always.Pass detector: python3 -m garak -m test.Blank -p mymodule -d always.Pass
  - For detectors, try a blank generator and a blank probe: python3 -m garak -m test.Blank -p test.Blank -d mymodule
  - For generators, try a blank probe and always.Pass detector: python3 -m garak -m mymodule -p test.Blank -d always.Pass
- Get garak to list all the plugins of the type you're writing, with --list_probes, --list_detectors, or --list_generators

FAQ

We have an FAQ here. Reach out if you have any more questions! leon@garak.ai

Code reference documentation is at garak.readthedocs.io.

Citing garak

You can read the garak preprint paper. If you use garak, please cite us.

@article{garak,
  title={{garak: A Framework for Security Probing Large Language Models}},
  author={Leon Derczynski and Erick Galinkin and Jeffrey Martin and Subho Majumdar and Nanna Inie},
  year={2024},
  howpublished={\url{https://garak.ai}}
}

"Lying is a skill like any other, and if you wish to maintain a level of excellence you have to practice constantly" - Elim

For updates and news see @garak_llm

NexaAI/nexa-sdk

2024-11-18T01:34:00Z

Probabilistic programming with NumPy powered by JAX for autograd and JIT compilation to GPU/TPU/CPU.

NumPyro

Probabilistic programming powered by JAX for autograd and JIT compilation to GPU/TPU/CPU.

Docs and Examples | Forum

What is NumPyro?

NumPyro is a lightweight probabilistic programming library that provides a NumPy backend for Pyro. We rely on JAX for automatic differentiation and JIT compilation to GPU / CPU. NumPyro is under active development, so beware of brittleness, bugs, and changes to the API as the design evolves.

NumPyro is designed to be lightweight and focuses on providing a flexible substrate that users can build on:

Pyro Primitives: NumPyro programs can contain regular Python and NumPy code, in addition to Pyro primitives like sample and param. The model code should look very similar to Pyro except for some minor differences between PyTorch and Numpy's API. See the example below.
Inference algorithms: NumPyro supports a number of inference algorithms, with a particular focus on MCMC algorithms like Hamiltonian Monte Carlo, including an implementation of the No U-Turn Sampler. Additional MCMC algorithms include MixedHMC (which can accommodate discrete latent variables) as well as HMCECS (which only computes the likelihood for subsets of the data in each iteration). One of the motivations for NumPyro was to speed up Hamiltonian Monte Carlo by JIT compiling the verlet integrator that includes multiple gradient computations. With JAX, we can compose jit and grad to compile the entire integration step into an XLA optimized kernel. We also eliminate Python overhead by JIT compiling the entire tree building stage in NUTS (this is possible using Iterative NUTS). There is also a basic Variational Inference implementation together with many flexible (auto)guides for Automatic Differentiation Variational Inference (ADVI). The variational inference implementation supports a number of features, including support for models with discrete latent variables (see TraceGraph_ELBO and TraceEnum_ELBO).
Distributions: The numpyro.distributions module provides distribution classes, constraints and bijective transforms. The distribution classes wrap over samplers implemented to work with JAX's functional pseudo-random number generator. The design of the distributions module largely follows from PyTorch. A major subset of the API is implemented, and it contains most of the common distributions that exist in PyTorch. As a result, Pyro and PyTorch users can rely on the same API and batching semantics as in torch.distributions. In addition to distributions, constraints and transforms are very useful when operating on distribution classes with bounded support. Finally, distributions from TensorFlow Probability (TFP) can directly be used in NumPyro models.
Effect handlers: Like Pyro, primitives like sample and param can be provided nonstandard interpretations using effect-handlers from the numpyro.handlers module, and these can be easily extended to implement custom inference algorithms and inference utilities.

A Simple Example - 8 Schools

Let us explore NumPyro using a simple example. We will use the eight schools example from Gelman et al., Bayesian Data Analysis: Sec. 5.5, 2003, which studies the effect of coaching on SAT performance in eight schools.

The data is given by:

>>> import numpy as np

>>> J = 8
>>> y = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0])
>>> sigma = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0])

, where y are the treatment effects and sigma the standard error. We build a hierarchical model for the study where we assume that the group-level parameters theta for each school are sampled from a Normal distribution with unknown mean mu and standard deviation tau, while the observed data are in turn generated from a Normal distribution with mean and standard deviation given by theta (true effect) and sigma, respectively. This allows us to estimate the population-level parameters mu and tau by pooling from all the observations, while still allowing for individual variation amongst the schools using the group-level theta parameters.

>>> import numpyro
>>> import numpyro.distributions as dist

>>> # Eight Schools example
... def eight_schools(J, sigma, y=None):
...     mu = numpyro.sample('mu', dist.Normal(0, 5))
...     tau = numpyro.sample('tau', dist.HalfCauchy(5))
...     with numpyro.plate('J', J):
...         theta = numpyro.sample('theta', dist.Normal(mu, tau))
...         numpyro.sample('obs', dist.Normal(theta, sigma), obs=y)

Let us infer the values of the unknown parameters in our model by running MCMC using the No-U-Turn Sampler (NUTS). Note the usage of the extra_fields argument in MCMC.run. By default, we only collect samples from the target (posterior) distribution when we run inference using MCMC. However, collecting additional fields like potential energy or the acceptance probability of a sample can be easily achieved by using the extra_fields argument. For a list of possible fields that can be collected, see the HMCState object. In this example, we will additionally collect the potential_energy for each sample.

>>> from jax import random
>>> from numpyro.infer import MCMC, NUTS

>>> nuts_kernel = NUTS(eight_schools)
>>> mcmc = MCMC(nuts_kernel, num_warmup=500, num_samples=1000)
>>> rng_key = random.PRNGKey(0)
>>> mcmc.run(rng_key, J, sigma, y=y, extra_fields=('potential_energy',))

We can print the summary of the MCMC run, and examine if we observed any divergences during inference. Additionally, since we collected the potential energy for each of the samples, we can easily compute the expected log joint density.

>>> mcmc.print_summary()  # doctest: +SKIP

                mean       std    median      5.0%     95.0%     n_eff     r_hat
        mu      4.14      3.18      3.87     -0.76      9.50    115.42      1.01
       tau      4.12      3.58      3.12      0.51      8.56     90.64      1.02
  theta[0]      6.40      6.22      5.36     -2.54     15.27    176.75      1.00
  theta[1]      4.96      5.04      4.49     -1.98     14.22    217.12      1.00
  theta[2]      3.65      5.41      3.31     -3.47     13.77    247.64      1.00
  theta[3]      4.47      5.29      4.00     -3.22     12.92    213.36      1.01
  theta[4]      3.22      4.61      3.28     -3.72     10.93    242.14      1.01
  theta[5]      3.89      4.99      3.71     -3.39     12.54    206.27      1.00
  theta[6]      6.55      5.72      5.66     -1.43     15.78    124.57      1.00
  theta[7]      4.81      5.95      4.19     -3.90     13.40    299.66      1.00

Number of divergences: 19

>>> pe = mcmc.get_extra_fields()['potential_energy']
>>> print('Expected log joint density: {:.2f}'.format(np.mean(-pe)))  # doctest: +SKIP
Expected log joint density: -54.55

The values above 1 for the split Gelman Rubin diagnostic (r_hat) indicates that the chain has not fully converged. The low value for the effective sample size (n_eff), particularly for tau, and the number of divergent transitions looks problematic. Fortunately, this is a common pathology that can be rectified by using a non-centered parameterization for tau in our model. This is straightforward to do in NumPyro by using a TransformedDistribution instance together with a reparameterization effect handler. Let us rewrite the same model but instead of sampling theta from a Normal(mu, tau), we will instead sample it from a base Normal(0, 1) distribution that is transformed using an AffineTransform. Note that by doing so, NumPyro runs HMC by generating samples theta_base for the base Normal(0, 1) distribution instead. We see that the resulting chain does not suffer from the same pathology — the Gelman Rubin diagnostic is 1 for all the parameters and the effective sample size looks quite good!

>>> from numpyro.infer.reparam import TransformReparam

>>> # Eight Schools example - Non-centered Reparametrization
... def eight_schools_noncentered(J, sigma, y=None):
...     mu = numpyro.sample('mu', dist.Normal(0, 5))
...     tau = numpyro.sample('tau', dist.HalfCauchy(5))
...     with numpyro.plate('J', J):
...         with numpyro.handlers.reparam(config={'theta': TransformReparam()}):
...             theta = numpyro.sample(
...                 'theta',
...                 dist.TransformedDistribution(dist.Normal(0., 1.),
...                                              dist.transforms.AffineTransform(mu, tau)))
...         numpyro.sample('obs', dist.Normal(theta, sigma), obs=y)

>>> nuts_kernel = NUTS(eight_schools_noncentered)
>>> mcmc = MCMC(nuts_kernel, num_warmup=500, num_samples=1000)
>>> rng_key = random.PRNGKey(0)
>>> mcmc.run(rng_key, J, sigma, y=y, extra_fields=('potential_energy',))
>>> mcmc.print_summary(exclude_deterministic=False)  # doctest: +SKIP

                   mean       std    median      5.0%     95.0%     n_eff     r_hat
           mu      4.08      3.51      4.14     -1.69      9.71    720.43      1.00
          tau      3.96      3.31      3.09      0.01      8.34    488.63      1.00
     theta[0]      6.48      5.72      6.08     -2.53     14.96    801.59      1.00
     theta[1]      4.95      5.10      4.91     -3.70     12.82   1183.06      1.00
     theta[2]      3.65      5.58      3.72     -5.71     12.13    581.31      1.00
     theta[3]      4.56      5.04      4.32     -3.14     12.92   1282.60      1.00
     theta[4]      3.41      4.79      3.47     -4.16     10.79    801.25      1.00
     theta[5]      3.58      4.80      3.78     -3.95     11.55   1101.33      1.00
     theta[6]      6.31      5.17      5.75     -2.93     13.87   1081.11      1.00
     theta[7]      4.81      5.38      4.61     -3.29     14.05    954.14      1.00
theta_base[0]      0.41      0.95      0.40     -1.09      1.95    851.45      1.00
theta_base[1]      0.15      0.95      0.20     -1.42      1.66   1568.11      1.00
theta_base[2]     -0.08      0.98     -0.10     -1.68      1.54   1037.16      1.00
theta_base[3]      0.06      0.89      0.05     -1.42      1.47   1745.02      1.00
theta_base[4]     -0.14      0.94     -0.16     -1.65      1.45    719.85      1.00
theta_base[5]     -0.10      0.96     -0.14     -1.57      1.51   1128.45      1.00
theta_base[6]      0.38      0.95      0.42     -1.32      1.82   1026.50      1.00
theta_base[7]      0.10      0.97      0.10     -1.51      1.65   1190.98      1.00

Number of divergences: 0

>>> pe = mcmc.get_extra_fields()['potential_energy']
>>> # Compare with the earlier value
>>> print('Expected log joint density: {:.2f}'.format(np.mean(-pe)))  # doctest: +SKIP
Expected log joint density: -46.09

Note that for the class of distributions with loc,scale parameters such as Normal, Cauchy, StudentT, we also provide a LocScaleReparam reparameterizer to achieve the same purpose. The corresponding code will be

with numpyro.handlers.reparam(config={'theta': LocScaleReparam(centered=0)}):
    theta = numpyro.sample('theta', dist.Normal(mu, tau))

Now, let us assume that we have a new school for which we have not observed any test scores, but we would like to generate predictions. NumPyro provides a Predictive class for such a purpose. Note that in the absence of any observed data, we simply use the population-level parameters to generate predictions. The Predictive utility conditions the unobserved mu and tau sites to values drawn from the posterior distribution from our last MCMC run, and runs the model forward to generate predictions.

>>> from numpyro.infer import Predictive

>>> # New School
... def new_school():
...     mu = numpyro.sample('mu', dist.Normal(0, 5))
...     tau = numpyro.sample('tau', dist.HalfCauchy(5))
...     return numpyro.sample('obs', dist.Normal(mu, tau))

>>> predictive = Predictive(new_school, mcmc.get_samples())
>>> samples_predictive = predictive(random.PRNGKey(1))
>>> print(np.mean(samples_predictive['obs']))  # doctest: +SKIP
3.9886456

More Examples

For some more examples on specifying models and doing inference in NumPyro:

Bayesian Regression in NumPyro - Start here to get acquainted with writing a simple model in NumPyro, MCMC inference API, effect handlers and writing custom inference utilities.
Time Series Forecasting - Illustrates how to convert for loops in the model to JAX's lax.scan primitive for fast inference.
Annotation examples - Illustrates how to utilize the enumeration mechanism to perform inference for models with discrete latent variables.
Baseball example - Using NUTS for a simple hierarchical model. Compare this with the baseball example in Pyro.
Hidden Markov Model in NumPyro as compared to Stan.
Variational Autoencoder - As a simple example that uses Variational Inference with neural networks. Pyro implementation for comparison.
Gaussian Process - Provides a simple example to use NUTS to sample from the posterior over the hyper-parameters of a Gaussian Process.
Horseshoe Regression - Shows how to implement generalized linear models equipped with a Horseshoe prior for both binary-valued and real-valued outputs.
Statistical Rethinking with NumPyro - Notebooks containing translation of the code in Richard McElreath's Statistical Rethinking book second version, to NumPyro.
Other model examples can be found in the examples site.

Pyro users will note that the API for model specification and inference is largely the same as Pyro, including the distributions API, by design. However, there are some important core differences (reflected in the internals) that users should be aware of. e.g. in NumPyro, there is no global parameter store or random state, to make it possible for us to leverage JAX's JIT compilation. Also, users may need to write their models in a more functional style that works better with JAX. Refer to FAQs for a list of differences.

Overview of inference algorithms

We provide an overview of most of the inference algorithms supported by NumPyro and offer some guidelines about which inference algorithms may be appropriate for different classes of models.

MCMC

NUTS, which is an adaptive variant of HMC, is probably the most commonly used inference algorithm in NumPyro. Note that NUTS and HMC are not directly applicable to models with discrete latent variables, but in cases where the discrete variables have finite support and summing them out (i.e. enumeration) is tractable, NumPyro will automatically sum out discrete latent variables and perform NUTS/HMC on the remaining continuous latent variables. As discussed above, model reparameterization may be important in some cases to get good performance. Note that, generally speaking, we expect inference to be harder as the dimension of the latent space increases. See the bad geometry tutorial for additional tips and tricks.
MixedHMC can be an effective inference strategy for models that contain both continuous and discrete latent variables.
HMCECS can be an effective inference strategy for models with a large number of data points. It is applicable to models with continuous latent variables. See here for an example.
BarkerMH is a gradient-based MCMC method that may be competitive with HMC and NUTS for some models. It is applicable to models with continuous latent variables.
HMCGibbs combines HMC/NUTS steps with custom Gibbs updates. Gibbs updates must be specified by the user.
DiscreteHMCGibbs combines HMC/NUTS steps with Gibbs updates for discrete latent variables. The corresponding Gibbs updates are computed automatically.
SA is the only MCMC method in NumPyro that does not leverage gradients. It is only applicable to models with continuous latent variables. It is expected to perform best for models whose latent dimension is low to moderate. It may be a good choice for models with non-differentiable log densities. Note that SA generally requires a very large number of samples, as mixing tends to be slow. On the plus side individual steps can be fast.

Like HMC/NUTS, all remaining MCMC algorithms support enumeration over discrete latent variables if possible (see restrictions). Enumerated sites need to be marked with infer={'enumerate': 'parallel'} like in the annotation example.

Nested Sampling

NestedSampler offers a wrapper for jaxns. See JAXNS's readthedocs for examples and Nested Sampling for Gaussian Shells example for how to apply the sampler on numpyro models. Can handle arbitrary models, including ones with discrete RVs, and non-invertible transformations.

Stochastic variational inference

Variational objectives
- Trace_ELBO is our basic ELBO implementation.
- TraceMeanField_ELBO is like Trace_ELBO but computes part of the ELBO analytically if doing so is possible.
- TraceGraph_ELBO offers variance reduction strategies for models with discrete latent variables. Generally speaking, this ELBO should always be used for models with discrete latent variables.
- TraceEnum_ELBO offers variable enumeration strategies for models with discrete latent variables. Generally speaking, this ELBO should always be used for models with discrete latent variables when enumeration is possible.
Automatic guides (appropriate for models with continuous latent variables)
- AutoNormal and AutoDiagonalNormal are our basic mean-field guides. If the latent space is non-euclidean (due to e.g. a positivity constraint on one of the sample sites) an appropriate bijective transformation is automatically used under the hood to map between the unconstrained space (where the Normal variational distribution is defined) to the corresponding constrained space (note this is true for all automatic guides). These guides are a great place to start when trying to get variational inference to work on a model you are developing.
- AutoMultivariateNormal and AutoLowRankMultivariateNormal also construct Normal variational distributions but offer more flexibility, as they can capture correlations in the posterior. Note that these guides may be difficult to fit in the high-dimensional setting.
- AutoDelta is used for computing point estimates via MAP (maximum a posteriori estimation). See here for example usage.
- AutoBNAFNormal and AutoIAFNormal offer flexible variational distributions parameterized by normalizing flows.
- AutoDAIS is a powerful variational inference algorithm that leverages HMC. It can be a good choice for dealing with highly correlated posteriors but may be computationally expensive depending on the nature of the model.
- AutoSurrogateLikelihoodDAIS is a powerful variational inference algorithm that leverages HMC and that supports data subsampling.
- AutoSemiDAIS constructs a posterior approximation like AutoDAIS for local latent variables but provides support for data subsampling during ELBO training by utilizing a parametric guide for global latent variables.
- AutoLaplaceApproximation can be used to compute a Laplace approximation.

Stein Variational Inference

See the docs for more details.

Installation

Limited Windows Support: Note that NumPyro is untested on Windows, and might require building jaxlib from source. See this JAX issue for more details. Alternatively, you can install Windows Subsystem for Linux and use NumPyro on it as on a Linux system. See also CUDA on Windows Subsystem for Linux and this forum post if you want to use GPUs on Windows.

To install NumPyro with the latest CPU version of JAX, you can use pip:

pip install numpyro

In case of compatibility issues arise during execution of the above command, you can instead force the installation of a known compatible CPU version of JAX with

pip install numpyro[cpu]

To use NumPyro on the GPU, you need to install CUDA first and then use the following pip command:

pip install numpyro[cuda] -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html

If you need further guidance, please have a look at the JAX GPU installation instructions.

To run NumPyro on Cloud TPUs, you can look at some JAX on Cloud TPU examples.

For Cloud TPU VM, you need to setup the TPU backend as detailed in the Cloud TPU VM JAX Quickstart Guide. After you have verified that the TPU backend is properly set up, you can install NumPyro using the pip install numpyro command.

Default Platform: JAX will use GPU by default if CUDA-supported jaxlib package is installed. You can use set_platform utility numpyro.set_platform("cpu") to switch to CPU at the beginning of your program.

You can also install NumPyro from source:

git clone https://github.com/pyro-ppl/numpyro.git
cd numpyro
# install jax/jaxlib first for CUDA support
pip install -e .[dev]  # contains additional dependencies for NumPyro development

You can also install NumPyro with conda:

conda install -c conda-forge numpyro

Frequently Asked Questions

Unlike in Pyro, numpyro.sample('x', dist.Normal(0, 1)) does not work. Why?

You are most likely using a numpyro.sample statement outside an inference context. JAX does not have a global random state, and as such, distribution samplers need an explicit random number generator key (PRNGKey) to generate samples from. NumPyro's inference algorithms use the seed handler to thread in a random number generator key, behind the scenes.

Your options are:
- Call the distribution directly and provide a PRNGKey, e.g. dist.Normal(0, 1).sample(PRNGKey(0))
- Provide the rng_key argument to numpyro.sample. e.g. numpyro.sample('x', dist.Normal(0, 1), rng_key=PRNGKey(0)).
- Wrap the code in a seed handler, used either as a context manager or as a function that wraps over the original callable. e.g.
```
with handlers.seed(rng_seed=0):  # random.PRNGKey(0) is used
    x = numpyro.sample('x', dist.Beta(1, 1))    # uses a PRNGKey split from random.PRNGKey(0)
    y = numpyro.sample('y', dist.Bernoulli(x))  # uses different PRNGKey split from the last one
```
  , or as a higher order function:
```
def fn():
    x = numpyro.sample('x', dist.Beta(1, 1))
    y = numpyro.sample('y', dist.Bernoulli(x))
    return y

print(handlers.seed(fn, rng_seed=0)())
```
Can I use the same Pyro model for doing inference in NumPyro?

As you may have noticed from the examples, NumPyro supports all Pyro primitives like sample, param, plate and module, and effect handlers. Additionally, we have ensured that the distributions API is based on torch.distributions, and the inference classes like SVI and MCMC have the same interface. This along with the similarity in the API for NumPy and PyTorch operations ensures that models containing Pyro primitive statements can be used with either backend with some minor changes. Example of some differences along with the changes needed, are noted below:
- Any torch operation in your model will need to be written in terms of the corresponding jax.numpy operation. Additionally, not all torch operations have a numpy counterpart (and vice-versa), and sometimes there are minor differences in the API.
- pyro.sample statements outside an inference context will need to be wrapped in a seed handler, as mentioned above.
- There is no global parameter store, and as such using numpyro.param outside an inference context will have no effect. To retrieve the optimized parameter values from SVI, use the SVI.get_params method. Note that you can still use param statements inside a model and NumPyro will use the substitute effect handler internally to substitute values from the optimizer when running the model in SVI.
- PyTorch neural network modules will need to rewritten as stax, flax, or haiku neural networks. See the VAE and ProdLDA examples for differences in syntax between the two backends.
- JAX works best with functional code, particularly if we would like to leverage JIT compilation, which NumPyro does internally for many inference subroutines. As such, if your model has side-effects that are not visible to the JAX tracer, it may need to rewritten in a more functional style.
For most small models, changes required to run inference in NumPyro should be minor. Additionally, we are working on pyro-api which allows you to write the same code and dispatch it to multiple backends, including NumPyro. This will necessarily be more restrictive, but has the advantage of being backend agnostic. See the documentation for an example, and let us know your feedback.
How can I contribute to the project?

Thanks for your interest in the project! You can take a look at beginner friendly issues that are marked with the good first issue tag on Github. Also, please feel to reach out to us on the forum.

Future / Ongoing Work

In the near term, we plan to work on the following. Please open new issues for feature requests and enhancements:

Improving robustness of inference on different models, profiling and performance tuning.
Supporting more functionality as part of the pyro-api generic modeling interface.
More inference algorithms, particularly those that require second order derivatives or use HMC.
Integration with Funsor to support inference algorithms with delayed sampling.
Other areas motivated by Pyro's research goals and application focus, and interest from the community.

Citing NumPyro

The motivating ideas behind NumPyro and a description of Iterative NUTS can be found in this paper that appeared in NeurIPS 2019 Program Transformations for Machine Learning Workshop.

If you use NumPyro, please consider citing:

@article{phan2019composable,
  title={Composable Effects for Flexible and Accelerated Probabilistic Programming in NumPyro},
  author={Phan, Du and Pradhan, Neeraj and Jankowiak, Martin},
  journal={arXiv preprint arXiv:1912.11554},
  year={2019}
}

as well as

@article{bingham2019pyro,
  author    = {Eli Bingham and
               Jonathan P. Chen and
               Martin Jankowiak and
               Fritz Obermeyer and
               Neeraj Pradhan and
               Theofanis Karaletsos and
               Rohit Singh and
               Paul A. Szerlip and
               Paul Horsfall and
               Noah D. Goodman},
  title     = {Pyro: Deep Universal Probabilistic Programming},
  journal   = {J. Mach. Learn. Res.},
  volume    = {20},
  pages     = {28:1--28:6},
  year      = {2019},
  url       = {http://jmlr.org/papers/v20/18-403.html}
}

sabamdarif/termux-desktop

2024-11-18T01:34:52Z

Install a full Linux desktop environment on your Android device with Termux X11 or VNC and also enable hardware acceleration. Additionally, install some popular GUI applications directly within Termux

Easily Install Termux Gui Desktop

Features:

📚 Easy To Setup
🖥 XFCE, LXQt, and OPENBOX supported
🎨 New Beautiful Theme And Styles
🍷 Wine To Run Windows Apps (x86_64 in arm64 device)
🦾 Hardware Acceleration Enabled
🖇 Termux:X11 / Vnc For Gui Access
📦 Work with both APT , PACMAN
🧩 One Click To Install Some useful Apps
- 🌐 Browser: Firefox / Chromium
- 👨💻 Code Editor: VS Code / Geany
- 📷 Image Editor: Gimp / Inkscape
- 🔗 More...
📦 Install apps like libreoffice (apps that are not avilable in termux by default)
🔗 And Much More...

⚠ Follow This Steps 👇

1. Check Basic Requirment: from here

2. Check All Avilable Desktop Styles:

XFCE

LXQT

OPENBOX

Openbox keybord shortcuts :- Here

3. Check About Hardware Acceleration : from here

4. Check About Distro Container: from here [Video Tutorial]

5. Check Natively Supported Apps list: from here

6. Installation: from here [Video Tutorial]

7. Uses: from here

8. See More: from here

Minimum Requirements:

No Root Required
Android 7+ phone
Termux From Github Or Fdroid

Termux from Google Play can't poperly install x11-packages due to API limitation, so instead use the F-Droid Or Github build.

2GB of RAM 3GB of RAM
1.5 - 2 GB Of Internet
3 - 4 GB Of Free Storage
VNC Client RealVnc Or Nethunter Kex
Termux:X11
Termux-API (For Openbox only)

Default Look (XFCE):

See Other Desktop And Their Avilable Styles: XFCE,LXQT,OPENBOX

Screenshots:

All gui apps screenshot

Browsers:

Image Editors:

Code Editors:

Media Players:

See More Natively Supported Apps: Here

Wine: See More

Want To Install More Apps (Like: Libreoffice) Which Are Not Avilable In Termux:

See How To Use Distro Container: Click Here

Libre Office:

Hardware Acceleration In Distro Container And Also In Termux:

Know More About Hardware Acceleration: Here

⚠ About The New The Experimental GPU Drivers

The experimental drivers only support a few GPUs and currently use Vulkan, with no OpenGL support.
In my tests, I achieved 1000+ FPS in vkmark on all my devices. I tried it on an Adreno 619 (best everything work fine), Adreno 750 (usable but some apps don't launch), Adreno 720 (good overall but with few issues), and Mali G76 (similar issue like Adreno 720).

Also if you have Adreno GPU then please select ubuntu or debian as distro container so it can use ternip in the distro container. Sadly for other then adreno, GPU might not work on the distro container.

If you type 'n/N' then it will use the old way to setup Hardware Acceleration.

Installation:

NOTE: This Only Works On Termux From Github Or Fdroid

NOTE: A Fresh Install Is Always Recommended

curl -Lf https://raw.githubusercontent.com/sabamdarif/termux-desktop/main/setup-termux-desktop -o setup-termux-desktop && chmod +x setup-termux-desktop && ./setup-termux-desktop

⚠If you are in android 12 or higher then first disable `Phantom Process Killer`

Guide:- Here

Uses:

Command:- `tx11start`

tx11start to star Termux:11 with gpu acceleration
tx11start --nogpu to star Termux:11 without gpu acceleration
tx11start --nogpu --legacy to star Termux:11 without gpu acceleration and -legacy-drawing
tx11start --nodbus to star Termux:11 without dbus
tx11start --nodbus --nogpu to star Termux:11 without gpu acceleration and dbus
tx11start --nodbus --nogpu --legacy to star Termux:11 without gpu acceleration and dbus and with -legacy-drawing
tx11start --nodbus --legacy to star Termux:11 without dbus and use -legacy-drawing (nodbus and gpu)
tx11start --legacy to star Termux:11 with -legacy-drawing (with dbus and gpu)

Command:- `tx11stop`

tx11stop to stop Termux:11
tx11stop -f to kill Termux:11

Command:- `vncstart`

vncstart to start vncserver
vncstart ---nogpu to start vncserver without gpu acceleration

Command:- `vncstop`

vncstop to stop vncserver
vncstop -f to kill vncserver

Command:- `gui`

If you select only one of them to access gui

gui --start / gui -l to start Termux gui
gui --stop / gui -s to stop gui

If you select both for gui access

gui -l / --start vnc to start VNC
gui -l / --start tx11 to start Termux:X11
gui -s / --stop vnc to stop VNC
gui -s / --stop tx11 to stop Termux:X11
gui -k / --kill / -kill to kill both vncserver and Termux:x11 At Once

Command:- `setup-termux-desktop`

setup-termux-desktop --change style To Change Desktop Style
setup-termux-desktop --change hw To Change Hardware Acceleration Method
setup-termux-desktop --change pd To Change Installed Proot-Distro
setup-termux-desktop --change autostart To change autostart behaviour

setup-termux-desktop --reinstall icons / themes /config To Reinstall Icons / Themes / Config
setup-termux-desktop --reinstall icons,themes,..etc To Reinstall Them At Once

setup-termux-desktop --reset To Reset All Changes Made By This Script Without Uninstalling The Packages

setup-termux-desktop --remove / -r To Remove Termux Desktop

setup-termux-desktop --debug (At The Start) To generate a log file for any of the above command

If you like my work then don't forget to give a Star 😊

base-org/basenames

2024-11-19T01:35:43Z

Base-native Identity

face-hh/lyntr

2024-11-19T01:35:52Z

Micro-blogging social media - with an IQ test. https://lyntr.com

abdulle-sabaf/cathunu-bhallifa

2024-11-18T01:35:24Z

悟数学

Github项目主页

简介

针对当前中学数学教材对自学者不友好，主流教辅、补习机构以题为纲，过于应试，过于碎片化的现状，我在大约2020年底萌发了整理中学数学乃至大学本科数学的中文自学材料的念头。《悟数学》是一个致力于重建中文数学自学体系的项目。它的主要目标是打通自学者接触高等数学的大门，让只有小学数学基础的人也能顺利自学完中学知识，扫除学习分析学、线性代数、拓扑学、概率论等知识的障碍。为此，我将把中学数学教育中应试和刻意练习的部分完全剥去，只留下知识脉络和技能导引。一切以和高等数学对接为先。

《悟数学》主要以课本形式呈现，仿照中国数学教科书体例，争取以脉络化、系统化的方式构建知识体系。内容大体和现行中学课本内容对应。分为初中六册，高中六册（如果有精力，会分出不同就学面向的版本，当前只有理工面向的计划）。课本用Latex编写，编译环境为Windows 10+Texlive 2021以上（源代码）。

我以迭代开发的思路做这个项目，初中六册完成即为《悟数学》1.0版本发布，高中理工面向完成为2.0版本发布。之后视情况可能还会有其他高中部分的其他面向以及线性代数、实分析、复分析、泛函、概率论、微分拓扑、近世代数等课程的入门教材。

从风格上来说，我将会把“逻辑自洽”和“顾名思义”两个原则作为追求。自学者要形成知识体系，必须依赖逻辑自洽，因此构建内容时我会十分注意前后概念的逻辑关联和可推导性，尽量减少需要强行记忆的内容。此外，出于中文本位思想，在名词概念的命名上，我将尽力采用可以顾名思义的名字，减少人名和音译的成分。本系列的部分术语和符号与中文数学界现行的主流用语、符号不同，为此特别制作《术语对照表》和《数学符号常例》（初中、高中），罗列所有与主流不同的用语、符号及对应的外语词汇，供读者查考。

预备知识

《悟数学》系列面向的是有小学数学学力的人。大体来说，掌握了自然数、小数和分数的四则运算，会列竖式；掌握平面基本图形的基本性质和面积公式；有基础的逻辑知识，比如知道什么是肯定和否定，知道“或”、“且”和“如果……就……”的含义，就可以开始学习了。

有初中或高中学力的学习者，在开始学习高等数学之前，想对自己的数学知识查缺补漏；或是刚开始学习高等数学的学习者，对高等数学和中学数学的联系难以把握，想要巩固基础，都可以通读《悟数学》系列，梳理自身所学。如果你之前只是为了中考、高考而学习数学，那么这个系列应当会让你有所收获。

如果对基础的逻辑知识没有把握，可以先看思理入门，熟悉相关的概念和用语。

内容

初中部分

高中部分（写作中）

Comfy-Org/ComfyUI_frontend

2024-11-18T01:35:35Z

Official front-end implementation of ComfyUI

ComfyUI_frontend

Official front-end implementation of ComfyUI.

Release Schedule

Nightly Release

Nightly releases are published daily at https://github.com/Comfy-Org/ComfyUI_frontend/releases.

To use the latest nightly release, add the following command line argument to your ComfyUI launch script:

--front-end-version Comfy-Org/ComfyUI_frontend@latest

For Windows Stand-alone Build Users

Edit your run_cpu.bat or run_nvidia_gpu.bat file as follows:

.\python_embeded\python.exe -s ComfyUI\main.py --windows-standalone-build --front-end-version Comfy-Org/ComfyUI_frontend@latest
pause

Stable Release

Stable releases are published weekly in the ComfyUI main repository, aligned with ComfyUI backend's stable release schedule.

Feature Freeze

There will be a 2-day feature freeze before each stable release. During this period, no new major features will be merged.

Release Summary

Major features

v1.3.22: Integrated server terminal

Press Ctrl + ` to toggle integrated terminal.

https://github.com/user-attachments/assets/eddedc6a-07a3-4a83-9475-63b3977f6d94

v1.3.7: Keybinding customization

Basic UI

Reset button

Edit Keybinding

rec.webm

v1.2.4: Node library sidebar tab

Drag & Drop

https://github.com/user-attachments/assets/853e20b7-bc0e-49c9-bbce-a2ba7566f92f

Filter

https://github.com/user-attachments/assets/4bbca3ee-318f-4cf0-be32-a5a5541066cf

v1.2.0: Queue/History sidebar tab

https://github.com/user-attachments/assets/86e264fe-4d26-4f07-aa9a-83bdd2d02b8f

v1.1.0: Node search box

Fuzzy search & Node preview

Release link with shift

https://github.com/user-attachments/assets/a1b2b5c3-10d1-4256-b620-345de6858f25

QoL changes

v1.3.32: **Litegraph** Nested group

https://github.com/user-attachments/assets/f51adeb1-028e-40af-81e4-0ac13075198a

v1.3.24: **Litegraph** Group selection

https://github.com/user-attachments/assets/e6230a94-411e-4fba-90cb-6c694200adaa

v1.3.6: **Litegraph** Toggle link visibility

rec.webm

v1.3.4: **Litegraph** Auto widget to input conversion

Dropping a link of correct type on node widget will automatically convert the widget to input.

rec.webm

v1.3.4: **Litegraph** Canvas pan mode

The canvas becomes readonly in pan mode. Pan mode is activated by clicking the pan mode button on the canvas menu or by holding the space key.

rec.webm

v1.3.1: **Litegraph** Shift drag link to create a new link

rec.webm

v1.2.62: **Litegraph** Show optional input slots as donuts

v1.2.44: **Litegraph** Double click group title to edit

https://github.com/user-attachments/assets/5bf0e2b6-8b3a-40a7-b44f-f0879e9ad26f

v1.2.39: **Litegraph** Group selected nodes with Ctrl + G

https://github.com/user-attachments/assets/7805dc54-0854-4a28-8bcd-4b007fa01151

v1.2.38: **Litegraph** Double click node title to edit

https://github.com/user-attachments/assets/d61d5d0e-f200-4153-b293-3e3f6a212b30

v1.2.7: **Litegraph** drags multiple links with shift pressed

https://github.com/user-attachments/assets/68826715-bb55-4b2a-be6e-675cfc424afe

https://github.com/user-attachments/assets/c142c43f-2fe9-4030-8196-b3bfd4c6977d

v1.2.2: **Litegraph** auto connects to correct slot

Before

https://github.com/user-attachments/assets/c253f778-82d5-4e6f-aec0-ea2ccf421651

After

https://github.com/user-attachments/assets/b6360ac0-f0d2-447c-9daa-8a2e20c0dc1d

v1.1.8: **Litegraph** hides text overflow on widget value

https://github.com/user-attachments/assets/5696a89d-4a47-4fcc-9e8c-71e1264943f2

Developer APIs

v1.3.34: Register about panel badges

app.registerExtension({
  name: 'TestExtension1',
  aboutPageBadges: [
    {
      label: 'Test Badge',
      url: 'https://example.com',
      icon: 'pi pi-box'
    }
  ]
})

v1.3.22: Register bottom panel tabs

app.registerExtension({
  name: 'TestExtension',
  bottomPanelTabs: [
    {
      id: 'TestTab',
      title: 'Test Tab',
      type: 'custom',
      render: (el) => {
        el.innerHTML = '<div>Custom tab</div>'
      }
    }
  ]
})

v1.3.22: New settings API

Legacy settings API.

// Register a new setting
app.ui.settings.addSetting({
  id: 'TestSetting',
  name: 'Test Setting',
  type: 'text',
  defaultValue: 'Hello, world!'
})

// Get the value of a setting
const value = app.ui.settings.getSettingValue('TestSetting')

// Set the value of a setting
app.ui.settings.setSettingValue('TestSetting', 'Hello, universe!')

New settings API.

// Register a new setting
app.registerExtension({
  name: 'TestExtension1',
  settings: [
    {
      id: 'TestSetting',
      name: 'Test Setting',
      type: 'text',
      defaultValue: 'Hello, world!'
    }
  ]
})

// Get the value of a setting
const value = app.extensionManager.setting.get('TestSetting')

// Set the value of a setting
app.extensionManager.setting.set('TestSetting', 'Hello, universe!')

v1.3.7: Register commands and keybindings

Extensions can call the following API to register commands and keybindings. Do note that keybindings defined in core cannot be overwritten, and some keybindings are reserved by the browser.

  app.registerExtension({
    name: 'TestExtension1',
    commands: [
      {
        id: 'TestCommand',
        function: () => {
          alert('TestCommand')
        }
      }
    ],
    keybindings: [
      {
        combo: { key: 'k' },
        commandId: 'TestCommand'
      }
    ]
  })

v1.3.1: Extension API to register custom topbar menu items

Extensions can call the following API to register custom topbar menu items.

  app.registerExtension({
    name: 'TestExtension1',
    commands: [
      {
        id: 'foo-id',
        label: 'foo',
        function: () => {
          alert(1)
        }
      }
    ],
    menuCommands: [
      {
        path: ['ext', 'ext2'],
        commands: ['foo-id']
      }
    ]
  })

v1.2.27: Extension API to add toast message

Extensions can call the following API to add toast messages.

  app.extensionManager.toast.add({
    severity: 'info',
    summary: 'Loaded!',
    detail: 'Extension loaded!',
    life: 3000
  })

Documentation of all supported options can be found here: https://primevue.org/toast/#api.toast.interfaces.ToastMessageOptions

v1.2.4: Extension API to register custom sidebar tab

Extensions now can call the following API to register a sidebar tab.

  app.extensionManager.registerSidebarTab({
    id: "search",
    icon: "pi pi-search",
    title: "search",
    tooltip: "search",
    type: "custom",
    render: (el) => {
      el.innerHTML = "<div>Custom search tab</div>";
    },
  });

The list of supported icons can be found here: https://primevue.org/icons/#list

We will support custom icons later.

Development

Tech Stack

Vue 3 with TypeScript
Pinia for state management
PrimeVue with TailwindCSS for UI
Litegraph for node editor
zod for schema validation

Git pre-commit hooks

Run npm run prepare to install Git pre-commit hooks. Currently, the pre-commit hook is used to auto-format code on commit.

Dev Server

Note: The dev server will NOT load any extension from the ComfyUI server. Only core extensions will be loaded.

Start local ComfyUI backend at localhost:8188
Run npm run dev to start the dev server
Run npm run dev:electron to start the dev server with electron API mocked

Access dev server on touch devices

Enable remote access to the dev server by setting VITE_REMOTE_DEV in .env to true.

After you start the dev server, you should see following logs:

> comfyui-frontend@1.3.42 dev
> vite


  VITE v5.4.6  ready in 488 ms

  ➜  Local:   http://localhost:5173/
  ➜  Network: http://172.21.80.1:5173/
  ➜  Network: http://192.168.2.20:5173/
  ➜  press h + enter to show help

Make sure your desktop machine and touch device are on the same network. On your touch device, navigate to http://<server_ip>:5173 (e.g. http://192.168.2.20:5173 here), to access the ComfyUI frontend.

Unit Test

git clone https://github.com/comfyanonymous/ComfyUI_examples.git to tests-ui/ComfyUI_examples or the EXAMPLE_REPO_PATH location specified in .env
npm i to install all dependencies
npm run test:generate to fetch tests-ui/data/object_info.json
npm run test:generate:examples to extract the example workflows
npm run test to execute all unit tests.

Component Test

Component test verifies Vue components in src/components/.

npm run test:component to execute all component tests.

Playwright Test

Playwright test verifies the whole app. See https://github.com/Comfy-Org/ComfyUI_frontend/blob/main/browser_tests/README.md for details.

LiteGraph

This repo is using litegraph package hosted on https://github.com/Comfy-Org/litegraph.js. Any changes to litegraph should be submitted in that repo instead.

Test litegraph changes

Run npm link in the local litegraph repo.
Run npm link @comfyorg/litegraph in this repo.

This will replace the litegraph package in this repo with the local litegraph repo.

Deploy

Option 1: Set DEPLOY_COMFYUI_DIR in .env and run npm run deploy.
Option 2: Copy everything under dist/ to ComfyUI/web/ in your ComfyUI checkout manually.

Publish release to ComfyUI main repo

Run following command to publish a release to ComfyUI main repo. The script will create a new branch and do a commit to web/ folder by checkout dist.zip from GitHub release.

python scripts/main_repo_release.py <path_to_comfyui_main_repo> <version>

fishttp/awesome-bluesky

2024-11-18T01:28:41Z

Admin repo for meetings, charter, and action items for the CSS-Next community group, a part of the w3c.

jessfraz/.vim

2024-11-19T01:36:27Z

My .vim dotfiles and configurations.

imsyy/vitepress-theme-curve

2024-11-19T01:36:29Z

🎉 A Simple VitePress Theme | 一个极简的 VitePress 主题

GitHub 1C Enterprise Daily Trending

docusealco/docuseal

garak, LLM vulnerability scanner

Get started

> See our user guide! docs.garak.ai

> Join our Discord!

> Project links & home: garak.ai

> Twitter: @garak_llm

> DEF CON slides!

LLM support

Install:

Standard install with pip

Install development version with pip

Clone from source

Getting started

Examples

Reading the results

Intro to generators

Hugging Face

OpenAI

Replicate

Cohere

Groq

ggml

REST

NIM

OctoAI

Test

Intro to probes

Logging

How is the code structured?

Developing your own plugin

FAQ

Citing garak

leaningtech/webvm

WebVM

Enable networking

Fork, deploy, customize

Local deployment

Example customization: Python3 REPL

Bugs and Issues

More links

Thanks to...

Versioning

License

epasveer/seer

💜 Sponsors

✨ Features

📸 Screenshots

⚡ Requirements

📦 Installation

🚀 Quickstart

⚙ Configuration

🛠 Changing the Defaults

🔌 Adapters

💡 Advanced Usage

📋 Prompt Library

💬 The Chat Buffer

✏ Inline Assistant

🤖 Agents / Tools

🗺 Agentic Workflows

🍭 Extras

🧰 Troubleshooting

🎁 Contributing

👏 Acknowledgements

ncalc/ncalc

NCalc

Docs

Learn more

Help

Getting Started

Functionalities

Simple Expressions

Related projects

Parlot

PanoramicData.NCalcExtensions

Jint

NCalcJS

NCalc101

JJMasterData

Standard install with `pip`

Install development version with `pip`