A probot library and application to make running repo-configurable scripts easy and powerful.

isobot lets you, a repo owner, write an executable script to do work.

• 🟢 Code! isobot lets you, the repo owner, run code. Testable, statically analyzable, sweet code.
• 🔴 Configuration. Most github/Probot applications use YAML or JSON configuration to drive bot activity. This is hard to get correct, and offers little in the way of 1) correctness verification, 2) flexibility!

Here's an example of a .github/isobot.ts file that sniffs for /merge comment commands, and has the bot approve and merge the PR.

export const pipeline: Pipeline = (
  stream,
  {
    rxjs: {
      operators: { filter, mergeMap },
    },
  }
) =>
  stream.pipe(
    filter((evt) => evt.name === "issue_comment"),
    mergeMap(

A powerful Terminal User Interface (TUI) application designed to enhance your vocabulary learning experience. Whether you're preparing for standardized tests like GRE, SAT, or simply wanting to expand your vocabulary, Vocab TUI provides an interactive and efficient way to practice and learn new words.

Vocab TUI is a Rust-based terminal application that combines the power of Large Language Models with a clean, intuitive interface to help you master vocabulary. The application features:

• Interactive terminal interface for efficient learning
• Real-time feedback on your word usage
• AI-powered sentence evaluation using Ollama
• Comprehensive word list targeting standardized test preparation
• Score tracking and detailed explanations for improvement

1. Rust Development Environment

   • Install Rust using rustup
   • Ensure you have Cargo (Rust's package manager) installed

2. Ollama Setup

   # Install Ollama
   curl -fsSL https://ollama.com/install.sh | sh
   
   # Pull required models
   ollama pull llama3.2
   ollama pull all-minilm

1. Clone the repository

   git

   …

A free and open source tool for generating beautiful Open Graph images, Twitter/X headers, and blog covers - no signup required.

• Multiple Template Types

  • Open Graph Images
  • Twitter/X Headers
  • Blog Cover Images
  • Custom Templates

• Rich Customization

  • Custom backgrounds (solid colors & gradients)
  • Grid and noise overlays
  • Logo upload support
  • Professional typography
  • Multiple export formats (PNG, JPEG, WebP)

• Developer Experience

  • Ready-to-use HTML meta tags
  • Next.js App Router integration
  • Real-time preview
  • No authentication required
  • Free and open source

• Node.js 18+
• pnpm (recommended) or npm

1. Clone the repository:

git clone https://github.com/weijunext/ogimage-click.git
cd ogimage.click

2. Install dependencies:

pnpm install

3. Set up environment variables in .env.local:

NEXT_PUBLIC_BASE_URL=http://localhost:3000
NEXT_PUBLIC_API_URL=http://localhost:3000/api
NEXT_PUBLIC_GOOGLE_ID=
NEXT_PUBLIC_GOOGLE_ADSENSE_ID=

4. Start the development server:

pnpm dev

• Next.js 15
• TypeScript
• Tailwind CSS
• Radix UI
• Satori
• Zod

1. Choose a template type (OG Image, Twitter Header, or Blog Cover)
2. Customize your content (text, colors, images)
3. …

Utility to mount Docker images locally without requiring container creation. This is useful for analysing contents of Docker images from within the host operating system without incurring the overhead of container creation.

This tool relies on some potentially unstable docker implementation details, and may break in future Docker versions!

This tool can be installed from PyPI using:

pip install docker-mounter

Alternatively, the tool can be installed from source using:

poetry install

Due to use of overlay2, tool is only compatible with Linux 3.19+.

It has currently only been tested with Docker version 27.3.1, build ce12230.

This tool requires:

1. Access to the Docker daemon socket (user must be root or in the docker group)
2. Root privileges when using the --mount option

Usage: docker-mount [OPTIONS] IMAGE
╭─ Arguments ─────────────────────────────────────────────────────────╮
│ *    image      TEXT  [default: None] [required]                    │
╰─────────────────────────────────────────────────────────────────────╯
╭─ Options ───────────────────────────────────────────────────────────╮
│ --mount-point                  PATH  [default: None]

This repository showcases our recent research aimed at improving the accuracy of large language models (LLMs) in mathematical domains. We believe our approach has surpassed previous methods, such as chain-of-thought and graph-of-thought techniques, achieving state-of-the-art performance.

In recent years, numerous prompting methods have been developed to guide large language models (LLMs) in tackling mathematical problems i.e Chain of Thought. However, their mathematical performance still falls short of satisfaction espically without fine tuning or zero-shot prompting. As a result, we have devised a novel approach to enhance this performance, which we call "divide and conquer." Unlike traditional applications of divide and conquer, our method proposes utilizing a programming language, such as Python, combined with an interpreter, simulating the way a human uses a calculator.

Our algorithm primarily focuses on mathematical problems, particularly computational challenges rather than proof-based issues. It first assesses…

📚 Checkout Documentation

When we interact with people 🗣️👂, we naturally remember details from past interactions 💭, feelings 😜😢, and shared experiences 🤝. That's what makes us human. We're bringing this same ability to AI, helping it recall just like us.

• Temporal Memory Recall: Enables AI to remember timestamped memories from past interactions.
• Multi-Tenancy: Accommodates multiple organizations, agents, and users.
• Flexible Name Handling: Uses placeholders for easy updates to user and agent names.
• Scalability: Designed to handle millions of users, interactions, and memories.
• Developer-Friendly: Modular architecture for easy customization and feature integration.

Before using Memora, you'll…

import (
    "testing"
    "github.com/razzie/mock"
)

type Fooer interface {
    Foo() error
}

func TestSomething(t *testing.T) {
    fooer, mck := mock.Mock[Fooer]() // <--- Mock generates a runtime mock implementation for Fooer
    mck.On("Foo").Return(nil)
    fooer.Foo()
    something(fooer)
    mck.AssertExpectations(t)
}

To properly understand the purpose of this package, you must be familiar with mocking and testify mock.

Let's say that in a hypothetical test scenario you need to mock the following Adder interface:

type Adder interface {
    Add(a, b int) int
}

The usual way to do it would be writing some MockAdder boilerplate code very similar to this:

import (
    "testing"
    "github.com/stretchr/testify/mock"
)
type MockAdder struct {
    mock.Mock
}

func

"Think globally, act locally"

Run your GitHub Actions locally! Why would you want to do this? Two reasons:

• Fast Feedback - Rather than having to commit/push every time you want to test out the changes you are making to your .github/workflows/ files (or for any changes to embedded GitHub actions), you can use act to run the actions locally. The environment variables and filesystem are all configured to match what GitHub provides.
• Local Task Runner - I love make. However, I also hate repeating myself. With act, you can use the GitHub Actions defined in your .github/workflows/ to replace your Makefile!

When you…

Freeplane is a free and open source software application that supports thinking, sharing information, getting things done at work, in school and at home. It provides you a set of tools for mind mapping (also known as concept mapping or information mapping) and navigating the mapped information. Freeplane is also a more robust and superior alternative to Xmind, Mindmeister, and similar mind mapping software.

Freeplane is written in Java using OSGi and Java Swing. It runs on any operating system that has a current version of Java installed. It can be installed or can run from removable storage like a USB drive.

Download and install the latest version over at Sourceforge. If you would like to report a bug, you can go report it over at Issues.

The documentation can be found at . There, you will find How-To Guides, FAQs, Examples and explanations about the functions…

Very fast C++17 logging library

git clone --recursive https://github.com/ChristianPanov/lwlog

cmake -B <Build Directory> -S <Directory of CMakeLists.txt> -DCMAKE_INSTALL_PREFIX=<Installation Directory>
cmake --build <Build Directory> --target install --config <Debug/Release>

find_package(lwlog_lib HINTS <Installation Directory>/lib/cmake)

target_link_libraries(MyExe PRIVATE lwlog::lwlog_lib)

The upcoming release of 1.4 brings a significant focus on performance optimization and resource efficiency.

What’s New:

• Introducing a static pre-allocated memory buffer for string manipulations to minimize dynamic memory allocations.
• Promotes memory reuse and improves performance for high-frequency logging scenarios.

Why It Matters:

• Reduces the overhead associated with creating and destroying temporary strings during log formatting.
• Particularly beneficial for applications requiring low-latency logging or operating in resource-constrained environments.

What’s New:

• Custom-built algorithms for converting floating-point and integer values to strings.
• Optimized to outperform std::to_string with more efficient operations.

Why…

Sway's yet another sway manager is a daemon for managing Sway WM's windows, workspaces, outputs, clipboard and PATH using FZF - both as floating foot windows and in the terminal.

It tries to deliver all these features in one command, without any configuration, and with a single binary, so it can be deployed easily:

sway-yasm daemon --default-keybindings

switcher	path
pick-space	pick-win
clipboard

Install using one of the following ways:

• binary from the releases page
• go install github.com/pancsta/sway-yasm/cmd/sway-yasm@latest
• git clone; cd; ./scripts/build

• window / workspace management
  • alt+tab / MRU order for windows
  • move a workspace to the current output
  • move a window to the current workspace
• miscellaneous management
  • run anything in your PATH
  • copy from clipboard history using clipman and wl-clipboard
• user command files (scripts)
  • resize-toggle
  • arrange
  • titlebar-toggle
• daemon (IPC & RPC) architecture, filesystem-free
• uses fzf, so renders in the terminal
• shows a…

Introduction · Features · Tech Stack · How to use · Author · Compare with Mkdirs · Notice · License · Credits

• Listings (Tools, Products)
• Item Detail Page
• Categories & Tags
• Authentication (GitHub and Google)
• Submission (built-in)
• Sanity Studio (built-in CMS)
• Blog (hidden by default)
• Documentation (hidden by default)
• Analytics (Umami & Google Analytics)
• SEO (Sitemap, Open Graph)
• Modern UI (Shadcn UI)
• Responsive Design
• Multi-language (English & Chinese)
• Multi-theme (Light & Dark)

• Next.js 14
• NextAuth
• Database (PostgreSQL)
• Tailwind CSS
• Shadcn UI
• Lucide Icons
• Contentlayer
• Sanity
• Vercel

1. Clone the repository
2. Run pnpm install
3. Configure the .env file
4. Run pnpm dev

This project is created by Javayhu, the founder of Mkdirs, which is the best directory boilerplate for anyone who wants to launch a profitable directory website in…

Star the project 🌟 to get releases notification and help growing the community

intuitem.com · SaaS Free trial · Roadmap · Docs · Languages · Discord · Frameworks

CISO Assistant brings a different take to GRC and Cyber Security Posture Management:

• by explicitly decoupling compliance from cybersecurity controls implementation
• has built-in standards, security controls and threats
• risk assessment and remediation plan follow-up
• allows to manage a catalog for security controls and threats
• you can bring your own framework as well using a simple syntax
• manage audit, evidences collection and report generation

Our vision is to provide a one stop shop for cyber security posture management and cover the layers of GRC (Governance, Risk and Compliance). As practitioners interacting with multiple cybersecurity and IT professionals, we have struggled with fragmentation and lack of efficient tooling. We keep improving CISO Assistant with anything that could bring clarity and productivity to cybersecurity teams…

📥 Model Download | ⚡ Quick Start | 📜 License | 📖 Citation
📄 Paper Link | 📄 Arxiv Paper Link | 👁️ Demo

Introducing DeepSeek-VL2, an advanced series of large Mixture-of-Experts (MoE) Vision-Language Models that significantly improves upon its predecessor, DeepSeek-VL. DeepSeek-VL2 demonstrates superior capabilities across various tasks, including but not limited to visual question answering, optical character recognition, document/table/chart understanding, and visual grounding. Our model series is composed of three variants: DeepSeek-VL2-Tiny, DeepSeek-VL2-Small and DeepSeek-VL2, with 1.0B, 2.8B and 4.5B activated parameters respectively DeepSeek-VL2 achieves competitive or state-of-the-art performance with similar or fewer activated parameters compared to existing open-source dense and MoE-based models.

DeepSeek-VL2: Mixture-of-Experts Vision-Language Models for Advanced Multimodal Understanding

Zhiyu Wu*, Xiaokang Chen*, Zizheng Pan*, Xingchao Liu*, Wen Liu**, Damai Dai, Huazuo Gao, Yiyang Ma, Chengyue Wu, Bingxuan Wang, Zhenda Xie, Yu Wu, Kai Hu, Jiawei Wang, Yaofeng Sun, Yukun Li, Yishi Piao, Kang…

Pagefind is a fully static search library that aims to perform well on large sites, while using as little of your users’ bandwidth as possible, and without hosting any infrastructure.

The full documentation on using Pagefind can be found at https://pagefind.app/.

More Pictures: https://wizardkeyboards.com/gallery/

Firmware: https://github.com/wizarddata/zmk/tree/Ergo_S-1_OE

Assembly Instructions & BOM: https://github.com/wizarddata/Ergo-S-1/blob/main/Ergo%20S-1%20OE%20Assembly%20Instructions.pdf

Customize the keyboard layout: https://github.com/arcanemachine/zmk-ergo-s-1

Download the Fusion 360 file: https://github.com/wizarddata/Ergo-S-1/blob/main/SOURCE/ergo-s-1-oe-rev0-v1.zip

What Is it?

The Ergo S-1 is a fully wireless, split ergonomic keyboard that is compatible with cherry/gateron switches and cherry/oem/dcs keycaps. It runs on the fantastic ZMK firmware.

Why Is It?

I love ergonomic keyboards. My first keyboard that I built was an Atreus, and how accessible that was for a beginner stuck with me. While I was unemployed in 2021 I spent my time designing an ergonomic keyboard that would be easy for a anyone to build.
This is the first step in acheiving that goal. The cases are designed to give you easy access to the switches for hand wiring. There's a parts list included for everything else that you'll need.

What Switches / Keycaps Can I…

A compute shader emulator for learning and debugging GPU compute shaders.

• Emulates GPU compute shader execution on CPU
• Simulates workgroups and subgroups with lockstep execution
• Supports GLSL subgroup operations
• Thread state visualization and debugging
• Works with any Nim code that follows compute shader patterns

# Compile with appropriate thread pool size and optimization settings
# -d:ThreadPoolSize=MaxConcurrentWorkGroups*(ceilDiv(workgroupSize, SubgroupSize)+1)
# -d:danger --threads:on --mm:arc
import std/math, computesim

type
  Buffers = object
    input: seq[int32]
    atomicSum: int32

proc reduce(b: ptr Buffers; numElements: uint32) {.computeShader.} =
  let gid = gl_GlobalInvocationID.x
  let value = if gid < numElements: b.input[gid] else: 0

  # First reduce within subgroup using efficient subgroup operation
  let sum = subgroupAdd(value)

  # Only one thread per subgroup needs to add to global sum
  if gl_SubgroupInvocationID == 0:
    atomicAdd b.atomicSum, sum

const
  NumElements = 1024'u32
  WorkGroupSize = 256

This repository showcases our recent research aimed at improving the accuracy of large language models (LLMs) in mathematical domains. We believe our approach has surpassed previous methods, such as chain-of-thought and graph-of-thought techniques, achieving state-of-the-art performance.

In recent years, numerous prompting methods have been developed to guide large language models (LLMs) in tackling mathematical problems i.e Chain of Thought. However, their mathematical performance still falls short of satisfaction espically without fine tuning or zero-shot prompting. As a result, we have devised a novel approach to enhance this performance, which we call "divide and conquer." Unlike traditional applications of divide and conquer, our method proposes utilizing a programming language, such as Python, combined with an interpreter, simulating the way a human uses a calculator.

Our algorithm primarily focuses on mathematical problems, particularly computational challenges rather than proof-based issues. It first assesses…

@evildojo666 presents...

with art assets by Krishna Palacio https://www.minifantasy.net

• raylib
• gcc or clang (but the Makefile assumes gcc for now)
• emsdk
• make
• liblua5.4-dev
• A custom-built version of liblua.a for the web build

1. Clone the repository
2. Change directory to the repository
3. Run the following command:

make

You will have to edit some of the hardcoded paths in the emcc instruction. I will provide details for this in the near future.

make index.html

./game

emrun index.html

Finite state machines (FSM, hereinafter referred to as state machines) are a very common design pattern in programs.

It contains two main concepts: state and message. The overall behavior of a state machine program is to continuously generate and process messages.

The state mainly helps people understand the generation and processing of messages at the code level.

Using zig's powerful type system and some programming specifications, we can implement type-safe finite state machines in zig.

It has the following two advantages:

Handwritten state machines have a great mental burden in actual code, and it is even more difficult to modify and refactor them.

typed-fsm-zig tracks the changes of state machines in terms of types, so that the…

A better API for asynchronous UDP

A websockets-like API for UDP

Here's an example echo server:

import asyncio
import signal
import aioudp


async def main():
    async def handler(connection):
        async for message in connection:
            await connection.send(message)

    loop = asyncio.get_running_loop()
    stop = loop.create_future()
    # Optional. This is for properly exiting the server when Ctrl-C is pressed
    # or when the process is killed/terminated
    loop.add_signal_handler(signal.SIGTERM, stop.set_result, None)
    loop.add_signal_handler(signal.SIGINT, stop.set_result, None)

    # Serve the server
    async with aioudp.serve("localhost", 9999, handler):
        await stop  # Serve forever

Session Recording

CyberPAM is a comprehensive Zero Trust Privileged Access Management solution designed for secure access to Windows, UNIX systems, and web applications. With its beautiful dark-themed interface and robust security features, it provides enterprise-grade access control and session monitoring capabilities.

I made CyberPAM for my own use, but I'm happy to share it with the community. I've been working with PAM products for years and CyberPAM is the culmination of my experience. Session recording is a must have for any PAM product, and CyberPAM is the best I've seen from an Admin perspective, and user experience. Often implementations of PAM products take a long time to get to production, but not CyberPAM.

Instructed by Prof. Ali Movaghar from the Department of Computer Engineering, Sharif University of Technology.

This repository contains a simulation of the M/M/1/K queue model, a classic queuing theory concept commonly used in the analysis of computer systems and network performance. These simulations are designed to analyze the performance of these queues under different scenarios.

Parameters:

• Service Rate (μ): The rate at which the service is provided.
• Arrival Rate (λ): The rate at which arrivals occur.
• Queue Capacity (K): Set to 14.

Key Aspects Covered:

• Performance Metrics: Calculation of the probability of having n customers in the system (P_n), average number of customers in the system (N_c), and probabilities of blocking (P_b) and dropping (P_d).
• Simulation Results: Results showing the impact of varying parameters on system performance.
• Formulas Used:
  • P_n(λ, μ) for the probability…

A framework for Recursive Feedback Systems in Bidirectional Math to Achieve Universal Stabilization.

This project presents a universal equation for stabilization and symmetry, providing a framework for understanding equilibrium in systems as diverse as physics, biology, economics, AI, cryptography and more. By unifying concepts across fields, it lays the groundwork for solving real-world problems in unprecedented ways.

- Basic example scripts are in the 'Basic_Scripts' folder.
- Experimental *implementations are in the 'Extensions' folder. *The core equation is implemented in diverse ways.
- Experimental frameworks are in the 'Frameworks' folder.
- An inverted pendulum example is in the 'Inverted_Pendulum_Feedback_System' folder.
- An image of the core equation and an ODE version of it are in the 'Images' folder.
- Documentation is in the 'docs' folder.

Abstract: This paper formalizes the recursive feedback system as a universal equation for achieving stabilization and symmetry across diverse domains. The properties…

[Blog] [Paper]

This repository provides the official implementations and experiments for Large Concept Models (LCM).

The LCM operates on an explicit higher-level semantic representation which we name a "concept". Concepts are language- and modality-agnostic and represent a higher level idea. In this work, a concept corresponds to a sentence, and we use the SONAR embedding space, which supports up to 200 languages in text and 57 languages in speech. See the list of supported languages here.

The LCM is a sequence-to-sequence model in the concepts space trained to perform auto-regressive sentence prediction. We explore multiple approaches:

• MSE regression (base_lcm in this code).
• Variants of diffusion-based generation (we include two_tower_diffusion_lcm in this release).
• Models operating in a quantized SONAR space (coming soon).

These explorations are performed using 1.6B parameter models and training data in the order…