Show-o and Show-o2 are research repositories for unified multimodal understanding and generation. They implement transformer-based models (1.3B, 1.5B, 7B parameters) that can perform text-to-image generation, image/video captioning, visual question answering, inpainting/extrapolation, and mixed-modality generation (interleaved text and images). The codebase is organized around two major model versions: Show-o uses discrete tokens with MAGVITv2 VAE and Phi-1.5 LLM, while Show-o2 moves to continuous latent space with WanVAE (3D causal VAE) and Qwen2.5 LLM. Training follows a multi-stage pipeline (pretraining, instruction tuning) with novel techniques like flow matching (via a modular `transport` package), dual-path vision encoders (SigLIP + patch embedding), and omni-attention masks that combine causal and bidirectional attention for multimodal sequences. The repository includes distributed training configs (DeepSpeed, multi-node), evaluation scripts for GenEval and DPG-Bench, and comprehensive YAML configuration files. This is primarily a data_research codebase: it produces research artifacts (models, papers at ICLR 2025 and NeurIPS 2025) rather than a production application. The code exhibits good modularity for a research project, with reusable components like the transport module, omni-attention masks, mixed dataloader, and attention masking utilities. However, it suffers from typical research-code issues: hardcoded internal infrastructure paths, reliance on non-public data pipelines (e.g., internal packages for RefinedWeb), and some code duplication between Show-o and Show-o2. Reproducibility is moderate—dependencies are pinned and configs are detailed, but many datasets are large-scale web sources that require manual setup, and the training scripts assume specific hardware (multi-node A100 clusters). The project is actively maintained (commits in early 2026) with a roadmap for future work, including mixed-modal generation and video support.
BosqueCore is a compiler and toolchain for the Bosque programming language, a research-oriented language emphasizing mechanized reasoning, deterministic execution, and safe-by-design programming. The repository implements a full compilation pipeline in TypeScript: a recursive-descent parser and lexer, a semantic type checker with advanced features (invariants, pre/post conditions, validated strings, numeric range types), an IR with monomorphization, and a C++ backend that generates garbage-collected, allocation-aware code. The CLI (`src/cmd/bosque.ts`) compiles `.bsq` files to C++ and produces executables via a Makefile build system. Extensive tests cover parser, typechecker, C++ emission, and runtime execution of sample programs (raytracer, nbody, binary tree). The architecture is cleanly split between frontend (AST, parsing, checking) and backend (IR, monomorphization, C++ emission), with a hand-written recursion-descent parser and a highly detailed type system. However, the codebase is a work in progress: many language features are explicitly unimplemented (tasks, switch, dispatch, multi-return, resource/env handling) with `assert(false, "Not implemented")` stubs, and large monolithic files (e.g., `parser.ts`, `checker.ts`, `flatten.ts`) concentrate complexity. The repository also includes a C++ runtime with a custom GC and allocators, plus a lexer/serializer for the BAPI IR format. As a research project transitioning toward practical use, it offers a unique, safety-focused language design but is not yet production-ready.
This repository is a curated collection of research papers on Multi-Agent Reinforcement Learning (MARL), organized by categories such as framework, cooperation, communication, and applications. It serves as a reference for researchers and practitioners in the field. The repository contains no code, data, or executable components; it is purely a markdown file with links to papers. The list is actively maintained and includes recent papers up to 2025. It is not a software application or data pipeline, but a static paper list.
This repository contains the research code for Video-SALMONN-2, a family of audio-visual large language models for video understanding, developed by Tsinghua University and ByteDance. It includes three generations: Video-SALMONN-2 (based on LLaVA), Video-SALMONN-2+ (based on Qwen2.5-VL), and Video-SALMONN-2 Pro (based on Qwen3-VL). The core contribution is a caption-enhanced training paradigm that tightly aligns audio and visual signals. The codebase provides full training pipelines for supervised fine-tuning (SFT) and direct preference optimization (DPO), along with evaluation scripts, a demo mode, and a vLLM-based serving plugin for deployment. While the project is predominantly research-focused, it includes application-like components such as CLI inference and OpenAI-compatible serving. The code exhibits high duplication across the three model variants, hardcoded paths to internal cluster storage, and brittle dependency pinning, making it challenging to reproduce outside the original environment. However, several components—such as the multimodal batch sampler, audio-video processing utilities, and QFormer-based fusion—are well-structured and potentially reusable for other multimodal research projects.
This repository is a research artifact from the NL2Bash project (LREC 2018), providing a dataset and neural semantic parser for translating natural language descriptions into Bash one-liners. The core contributions include a parallel corpus of ~10k NL–Bash pairs, TensorFlow-based sequence-to-sequence models with attention and copy mechanisms, a custom Bash command parser (bashlint) that normalizes commands using a grammar extracted from man pages, and evaluation tools including tree edit distance and manual judgment pipelines. The codebase is primarily a research prototype with pre-trained model checkpoints, data preprocessing scripts, and evaluation files. While the dataset and parser are valuable, the dependency on TensorFlow 1.x, JavaCC, and Python 2/3 compatibility indicates significant drift. The repository is no longer actively maintained, but the documented methodology and reusable components (e.g., tree edit distance, statistical spell checker) remain relevant for similar NL-to-code tasks.
CameraBench is a benchmark and research project for evaluating camera motion understanding in videos, comparing classical Structure-from-Motion (SfM) methods and modern Vision-Language Models (VLMs). The repository serves as a landing page with download scripts for the test dataset (videos and labels from Hugging Face), a leaderboard showing model performance, and links to fine-tuned Qwen2.5-VL models. The actual evaluation and training code resides in a separate repository (t2v_metrics). The repo lacks a self-contained pipeline, dependency management, or data processing scripts; it is essentially a static site with download helpers. A notebook template for a ReLU activation function exercise is included but is unrelated to the core project. The benchmark is novel and published at NeurIPS 2025, but the codebase itself is minimal and not reusable beyond data retrieval.
This repository is a personal collection of study notes and PDF papers focused on large language models for recommendation systems (LLM4Rec). It contains markdown notes summarizing topics such as SNS-based LLM post-training, vocabulary customization for LLMs, LLM-to-SQL techniques, and algorithm explanations (e.g., longest palindrome substring). The majority of files are PDF research papers and reference materials, with no source code, configuration, or executable components. The content serves as a reference library for the maintainer's learning and interview preparation.