WeUI is a UI library designed to match WeChat's native visual experience for web pages and mini-programs. It provides a comprehensive set of reusable CSS-based components (buttons, cells, forms, dialogs, etc.) with WeChat-specific styling and interactions. The architecture is modular, with core styles written in LESS and organized by component type, accompanied by extensive HTML examples demonstrating usage. The library relies on external tools like Gulp, Less, and Autoprefixer for building and preprocessing, but produces standalone CSS output for consumption in web projects.

ncnn is a high-performance neural network inference framework designed for mobile, embedded, and desktop deployment. It provides a self-contained C++ library with no mandatory external dependencies, supporting CPU inference with extensive SIMD optimizations (ARM NEON, x86 SSE/AVX/AVX512, RISC-V Vector, MIPS MSA, LoongArch LSX/LASX) and GPU inference via Vulkan. The framework includes a comprehensive set of neural network layers (convolution, pooling, normalization, activation, recurrent, attention, etc.) and supports multiple data types (float32, float16, bfloat16, int8). The companion pnnx tool converts models from PyTorch (TorchScript) and ONNX into ncnn format using a sophisticated graph rewriting pipeline. Python bindings and a model zoo are provided for rapid prototyping. The codebase is production-grade, used in Tencent applications like QQ and WeChat, and is actively maintained with support for modern architectures and operations (e.g., scaled dot-product attention, rotary embeddings).

Hippy is a cross-platform mobile application framework developed by Tencent that enables developers to build native mobile apps using JavaScript with React or Vue. It provides a JS driver layer that communicates with native renderers on Android, iOS, OpenHarmony, and Web via a bridge system. The architecture is modular: a DOM layer manages the virtual tree and layout (using Taitank or Yoga), native renderers create platform-specific UI components, and a virtual file system (VFS) handles resource loading. The framework includes a full devtools backend implementing Chrome DevTools Protocol for debugging, performance monitoring, and DOM inspection. Key entry points include the JS bootstrap (hippy.js), native engine managers (HippyEngine on Android, HippyBridge on iOS), and the JS framework adapters (hippy-react, hippy-vue, hippy-vue-next). External dependencies include V8, Hermes, JSC, or JSH JavaScript engines, and platform-specific SDKs (AndroidX, UIKit, ArkUI). The codebase is large and actively maintained, with multiple renderer implementations and both Vue 2 and Vue 3 support, though some duplication and deprecated code exist.

Tencent/wujie is a production-grade micro-frontend framework that achieves native-level isolation by combining iframe sandboxing for JavaScript execution with Web Components (Shadow DOM) for CSS scoping. Unlike other micro-frontend solutions that rely on JavaScript sandbox polyfills (e.g., 'with' statements), Wujie leverages the browser's built-in iframe security model, making it robust against prototype pollution and global variable conflicts. The framework is implemented as a monorepo containing a core library (wujie-core), framework-specific integrations for Vue 2/3 and React, comprehensive examples, and an extensive test suite. The core provides lifecycle APIs (startApp, preloadApp, destroyApp) and supports multiple running modes: alive (keep-alive), singleton (lifecycle-based), and rebuild (full destroy each time). It includes a plugin system for custom asset loaders (HTML, CSS, JS), routing synchronization between main and sub-apps, and a decentralized EventBus for cross-application communication. The architecture handles degradation gracefully: if Proxy or WebComponent is unavailable, it falls back to a pure iframe with Object.defineProperty-based sandbox. The repository exhibits high craftsmanship in several areas: a dedicated EventCleanupTracker for preventing memory leaks, a custom proxy generator that patches cross-realm instanceof checks, and deferred style loading to support libraries like TinyMCE. Integration and unit tests cover lifecycle, plugins, routing sync, and memory leak scenarios. The accompanying documentation site provides detailed guides and API references. However, the codebase shows signs of maintenance burden: the example sub-apps use outdated frameworks (Angular 12, React 16/17), the integration test setup is complex and slow, and the dense patching of native DOM APIs introduces fragility across browser updates. Overall, it is a well-architected and actively maintained solution for micro-frontend orchestration.

TMagic Editor is a low-code visual page builder framework developed by Tencent. It provides a WYSIWYG drag-and-drop editor for assembling pages from a library of components (Vue and React), configuring properties via schema-driven forms, binding data sources (HTTP, static, mock), attaching JavaScript code blocks for custom logic, and defining event/action flows. The editor outputs a structured DSL (JSON) that can be rendered by separate runtime packages for Vue 2/3 and React, making it suitable for building internal tools, marketing pages, or any form-based application. Architecturally, the project is a monorepo with over 20 packages. The core editor (`packages/editor`) is built with Vue 3 and Element Plus (with an adapter for TDesign), and relies on a canvas stage (`packages/stage`) using the Moveable library for element selection, resizing, and dragging. Property forms are rendered by a headless-capable form engine (`packages/form`) that supports validation, dynamic fields, and complex containers (tabs, tables, group lists). Data sources are managed through an observable pattern (`packages/data-source`) with dependency tracking (`packages/dep`) that can be offloaded to a Web Worker. The system includes a CLI tool (`packages/cli`) for generating runtime entry files and a comprehensive SDK (`packages/editor/src/sdk`) for programmatic DSL manipulation without a browser DOM. Key features include multi-page and page-fragment support, undo/redo with IndexedDB persistence, dependency analysis for incremental updates, a plugin system for extending editor services, and a design abstraction layer that allows switching between UI frameworks. The codebase is well-tested with Vitest, follows modern TypeScript practices, and includes extensive documentation via VitePress. While primarily a developer tool for creating custom editors, it also ships with a playground for demonstration and testing.

This repository is the monorepo for Cherry Markdown, a rich, extensible WYSIWYG markdown editor library developed by Tencent. The core package (`packages/cherry-markdown`) provides a modular parsing engine with a plugin-based syntax hook system, a comprehensive toolbar, streaming rendering for AI chat, and support for diagrams (Mermaid, PlantUML, ECharts), math (KaTeX/MathJax), tables, and code blocks. The repository also includes a desktop client built with Tauri (Vue 3 + Pinia + Rust) that adds file management, local versioning, and native integrations; a VS Code extension; a WeChat Mini Program renderer; and various example applications. The architecture is well-structured with clear separation of concerns (engine, previewer, editor, toolbar, addons), extensive unit tests, and a consistent event-driven pattern. While the core library is JavaScript with JSDoc types, the client and plugins are TypeScript. Some technical drift exists due to vendored third-party assets (e.g., drawio library), a partially implemented Milkdown adapter, and a few deprecated code paths. Overall, this is a mature, actively maintained editor framework with high reusability in its hook system, utility classes, and composable patterns.

This repository is a high-performance computing library optimized for large language model (LLM) inference and training on NVIDIA GPUs. It provides accelerated implementations of core operations including attention mechanisms, GEMM, fused Mixture of Experts (MoE), all-reduce with normalization, sampling, and rotary position embeddings. The architecture combines C++/CUDA kernels for performance-critical operations with Python bindings via PyTorch, enabling easy integration into deep learning frameworks. The library emphasizes kernel fusion, efficient memory access patterns, and specialized optimizations for modern GPU architectures (particularly Hopper and Blackwell).