github-linguist/linguist

This system is a language detection and analysis library, primarily used to identify programming languages in source code repositories. It provides a modular pipeline for detecting languages based on file extensions, content heuristics, and other strategies, supported by a comprehensive library of sample files for testing and validation. The system also offers command-line tools for generating repository-level language statistics and managing detection caches.

194 changes.

The project significantly expanded its library of language samples to improve syntax highlighting and detection accuracy across a vast array of programming languages, frameworks, and configuration formats. Concurrently, the core language detection logic was refactored into a modular strategy pipeline to enhance performance and allow for instrumentation.

159 changes.

This period focused on massively expanding the repository's sample library to support syntax highlighting and detection for a vast array of programming languages, configuration formats, and data standards. The work involved adding reference implementations for diverse technologies ranging from niche languages like Brainfuck and REXX to modern frameworks like Svelte and Blazor, alongside numerous system-level formats such as linker scripts and DNS zones. Additionally, the period saw the introduction of new CLI tools and a performance-critical C-based tokenizer to improve the underlying language detection engine.

150 changes.

This period was defined by the continuous addition of sample files and language support across a vast array of programming languages, configuration formats, and domain-specific tools. The work focused on populating the repository with reference implementations for syntax highlighting, including smart contracts, build systems, and specialized data formats. It also included minor organizational changes to directory structures and the introduction of development environment configurations.

23 changes.

This period focused on significantly expanding the project's sample library by adding reference implementations for a wide variety of specialized languages and tools. New entries covered domains ranging from distributed systems and formal verification to database schemas, UI frameworks, and configuration management. The work provided users with practical examples for syntax, integration, and complex logic across these diverse technologies.

This change introduces a new sample application written in 1C Enterprise (BSL) language within the \samples/1C Enterprise\ directory. The sample demonstrates a business workflow including outgoing correspondence management (with email sending and contact lookup), product catalog price list printing, and goods expense processing with inventory and financial movement registration. It also includes infrastructure scripts for CI compilation testing and mobile data synchronization modules.

samples/1C Enterprise · high confidence

Added two new 2DA data files, appearance.2da and tailmodel.2da, to the samples/2-Dimensional Array directory. The appearance file defines visual and movement properties for a wide range of creature models (including humanoids, dragons, and beasts), while the tailmodel file maps specific tail and horse-barding models to their corresponding identifiers.

samples/2-Dimensional Array · high confidence

Added a new ABAP sample file (cl\_csv\_parser.abap) in the samples/ABAP directory that provides a class for parsing CSV strings. This sample demonstrates how to implement a CSV parser in ABAP, including handling separators, quoted text, and error conditions.

samples/ABAP · high confidence

Added two new sample files in the samples/ASL directory: example.asl, which demonstrates ACPI extensions for PCIe and memory controller configuration including CTDP power limit controls, and example.dsl, which provides a sample SSDT for PCI memory ranges and S3/S4/S5 suspend states.

samples/ASL · high confidence

Added sample AIDL files in the samples/AIDL directory, including ExtendableParcelable.aidl and IVoid.aidl, to demonstrate Android Interface Definition Language usage.

samples/AIDL · high confidence

New AL sample files have been added to the samples/AL directory, including a table (ALIssue), a list page (ALIssueList), and a codeunit (RefreshALIssueCode) that fetches and displays GitHub repository issues via a web service call. Additionally, sample profile and profile extension files (BomProfile.al, BlankProfileExt.al) are included to demonstrate profile configuration.

samples/AL · high confidence

A new ALGOL sample file (example15.alg) has been added to the samples directory. This example demonstrates the use of arrays with non-constant bounds and recursive procedure calls, providing users with a reference implementation for these language features.

samples/ALGOL · high confidence

A new pricing page has been added to the Edge samples, detailing the features and benefits of the Adocasts Plus subscription. The page highlights perks such as access to all content, early access to new lessons, an ad-free experience, and the ability to run ads. It also includes a call-to-action for free sign-ups and an FAQ section addressing subscription management, plan changes, and discount requests.

samples/Edge · high confidence

Added three new Aleo sample programs to the samples directory: arrays\_in\_finalize.aleo, which demonstrates array equality checks within finalize blocks; key\_value\_store.aleo, which illustrates mapping operations including insert, contains, remove, and view retrieval; and signature\_verification.aleo, which provides examples for verifying signatures, using constant signatures, and performing literal operations on signature types.

samples/Aleo · high confidence

Added a sample Altium Designer project (\Sample Altium Project.PrjPcb\) and its associated board design file (\Sample Board Design.PcbDoc\) to the samples directory, providing a reference implementation for users working with Altium Designer formats.

samples/Altium Designer · high confidence

New sample files have been added to the Answer Set Programming and Linear Programming directories, providing concrete examples for ASP and LP formats. The ASP samples include encodings for the 15-puzzle, APT package management, Spack error message generation, and the Tower of Hanoi, along with a Python-integrated script example. The Linear Programming samples provide model definitions for multi-objective optimization and a diet problem.

samples/Answer Set Programming · high confidence

New AppleScript samples have been added to the repository, providing users with ready-to-use scripts for common macOS tasks. These include converting images to PDF or PostScript formats using system utilities, automating the Mail application to count messages across mailboxes and generate styled outgoing messages, retrieving the current user name via UI element scripting, speaking the time of day with VoiceOver support, and programmatically centering and resizing the frontmost application window in Safari.

samples/AppleScript · high confidence

Added four new sample files in the samples/AutoHotkey directory demonstrating how to create a GUI with a hotkey input field and a button to register custom hotkeys. The samples include hello.ah1 and hello.ahkl using the legacy AutoHotkey Basic syntax, and hello.ah2 and hello.ahk using the modern AutoHotkey v2 syntax with object-oriented GUI and event handling.

samples/AutoHotkey · high confidence

A new B4X sample application has been added to the samples directory, providing a cross-platform implementation for B4A, B4J, and B4i. The sample includes a main page component that initializes and manages a game instance while handling platform-specific UI adjustments such as iPhone safe areas. It also features an OAuth authentication module that supports sign-in flows via local server sockets on B4J and intent/url handling on B4A and B4i, along with a network request manager capable of cancelling active HTTP requests across all three platforms.

(repo-wide) · high confidence

Added new sample directories for Bikeshed and BrighterScript. The Bikeshed samples include example specification source files (example.bs, example2.bs) for the WebAssembly JavaScript Interface and Web Audio API, demonstrating the use of the Bikeshed documentation tool. The BrighterScript samples provide demonstration code for Roku development, including a main script showcasing language features like ternary operators, template strings, null-coalescing, and source literals, along with utility scripts for grid and row list UI components.

samples/Bikeshed, samples/BrighterScript · high confidence

Added sample BitBake files to the repository, including the \cmake.bbclass\ for configuring CMake builds (with support for Ninja/Unix Makefiles, cross-compilation toolchains, and compiler flags), and several \.bb\ and \.inc\ files for \gstreamer-libav\, \qtbase-native\, \qtbase\ (Raspberry Pi configuration), \tclibc-newlib\, and \xorg-driver-common\. These samples provide reference implementations for common build patterns and dependencies within the BitBake ecosystem.

samples/BitBake · high confidence

Added sample Bluespec BHC files including CGetPut (credit-based FIFO interfaces), COBS (Consistent Overhead Byte Stuffing encoder/decoder), and a traffic light controller (TL) with its testbench (TbTL).

samples/Bluespec BH · high confidence

Added three new Boogie program files (Bubble.bpl, TuringFactorial.bpl, ticket.bpl) to the samples/Boogie directory, providing verification examples for bubble sort, Turing's additive factorial, and a ticket-based concurrency protocol.

samples/Boogie, samples/Promela · high confidence

A new BuildStream element (hello.bst) has been added to the samples directory, demonstrating how to manually build a project by depending on a base system, staging local source files, and executing make commands for both building and installation.

samples/BuildStream · high confidence

Added sample COOL language programs to the samples/Cool directory, including a linked-list implementation (list.cl) and a comprehensive example demonstrating language constructs such as conditionals, loops, assignment, case statements, and let expressions (sample.cl).

samples/Cool · high confidence

Added a new collection of CQL (Cassandra Query Language) sample scripts in the samples/CQL directory. These files provide practical examples for managing Cassandra resources, including creating keyspaces with various replication strategies, defining tables for use cases like video databases and user ratings, and altering tables, materialized views, types, and roles.

samples/CQL · high confidence

Added four new CSON sample files in the samples/CSON directory to demonstrate configuration structures, syntax highlighting rules, and menu definitions. The base.cson file provides keybinding examples for Atom text editors and native input fields. The config.cson file illustrates directory and file icon settings for various project types like Git, Bower, and NodeJS. The ff-sfd.cson file defines syntax highlighting patterns for Spline Font Database (.sfd) files, including support for private sections, images, and color codes. The wercker-status.cson file shows a menu configuration for the Wercker Status package.

samples/CSON · high confidence

Added two new sample files in the samples/CWeb directory: mpmathdouble.w, which provides IEEE double-precision math support functions for MetaPost, and sat-life.w, which generates SAT clauses for Conway's Game of Life transitions. These files serve as examples of CWeb source code for the MetaPost project.

samples/CWeb · high confidence

A new sample file, Foo.ceylon, has been added to the Ceylon samples directory. It provides a basic example of Ceylon syntax, including a shared test function that prints output and a shared Test class that implements the Comparable interface to demonstrate string comparison logic.

samples/Ceylon · high confidence

Added a new set of sample programs for the Chapel parallel programming language, including a 'Hello, world!' example, a parallel quicksort implementation, an n-body simulation, a distributed array distributions primer, and a port of the LULESH hydrodynamics benchmark.

samples/B, samples/Chapel, samples/JASS · high confidence

Added sample Circom circuit templates (binsum, switcher, xor3) to the samples/Circom directory, providing reference implementations for binary summation, signal switching, and 3-input XOR operations using the Circom 2.0.0 syntax.

samples/Circom · high confidence

Added three new Clarity smart contract samples to the \samples/Clarity\ directory: \bns.clar\ (implementing the Stacks Name Service with namespace and name registration logic), \cost-voting.clar\ (providing a mechanism for proposing and voting on cost functions), and \pox.clar\ (implementing Proof-of-Transfer stacking and delegation features). These files serve as reference implementations for core Stacks protocol features.

samples/Clarity · high confidence

The samples directory now includes a variety of Clojure code examples, such as a Hoplon-based TodoMVC app, Hiccup HTML templates, and utilities for protocols and SVG. It also adds a Babashka script for linting and formatting Clojure source files, and introduces the .bb file extension for Babashka scripts.

samples/Clojure · high confidence

A new sample file (example.soy) has been added to the samples/Closure Templates directory, demonstrating a Closure Templates (.soy) template with parameter handling, conditional rendering, and template calls.

samples/Closure Templates · high confidence

The samples/Clue directory now contains a complete terminal-based game called "IP Please!" written in the Clue language. The sample includes a game loop (main.clue), a command system for managing user connections (game.clue, player.clue), a terminal UI with scrolling and typing effects (terminal.clue), a graph plotting utility (graph.clue, line.clue), and a MessagePack serialization library (msgpack.clue). Users can run this sample to see a working Clue application that involves filtering network users based on age, IP glitches, and hacker status.

(repo-wide) · high confidence

New CoNLL-U format sample files have been added to the samples/CoNLL-U directory, providing annotated test data for Portuguese (CF1.conllu), English (en-ud-test-abridged.conllu), and Uyghur (ug-ud-test-abridged.conllu). These files allow users to verify parsing capabilities and format compliance for these specific languages.

samples/CoNLL-U · high confidence

Added sample files to demonstrate ColdFusion syntax, including \samples/ColdFusion/example.cfm\ for standard HTML-based ColdFusion Markup Language and \samples/ColdFusion CFC/\ containing \exampleScript.cfc\ (script-based component) and \exampleTag.cfc\ (tag-based component). These samples illustrate ColdFusion date functions, output grouping, arithmetic operations, nested comments, and component structures with dependency injection.

samples/ColdFusion, samples/ColdFusion CFC · high confidence

Added sample source files for Common Lisp and PicoLisp to the repository. The Common Lisp samples include \array.l\, \common.l\, \config.sexp\, \hello.lisp\, \macros-advanced.cl\, \motor-inferencia.cl\, \rss.sexp\, \sample.lisp\, and \sample.lsp\, covering array operations, macros, inference engines, and configuration. A PicoLisp sample \simul.l\ was also added, demonstrating permutation, genetic algorithms, and grid manipulation.

samples/Common Lisp · high confidence

A new Perl XS extension sample (CommonMark.xs) has been added to the samples/XS directory, providing a Perl interface to the libcmark library for parsing Markdown and rendering it to HTML, XML, and man pages.

samples/XS · high confidence

Added sample Cooklang recipe files (advanced\_recipe.cook, simple\_recipe.cook) to the samples directory, providing examples of the Cooklang syntax for users to reference.

samples/Cooklang · high confidence

Added sample Cylc workflow files (\cset.cylc\, \cset-include.cylc\, \model.cylc\) to the \samples/Cylc\ directory, providing templates for running the CSET analysis suite and a generic model build/run cycle.

samples/Cylc · high confidence

New DTrace probe scripts have been added to the samples/DTrace directory to assist with tracing and debugging. The new files include counts.d for tracking PHP function call counts and execution time, probes.d defining a comprehensive set of PostgreSQL backend probes (covering transactions, locks, queries, buffers, WAL, and checkpoints), and trace\_futexes.d for monitoring Linux futex operations, including error conditions, lock statistics, and timing metrics.

samples/DTrace · high confidence

New Dafny specification files have been added to the samples directory: Io.s.dfy provides axiomatic models for host environment, time, and UDP networking operations, while Node.i.dfy implements the logic for a distributed lock node, including initialization, granting, and accepting lock transfers.

samples/Dafny · high confidence

A new sample script named DeepakChopra.opal has been added to the samples/Opal directory. This script demonstrates the language's capabilities by generating randomized, pseudo-profound sentences using predefined lists of starting phrases, middles, qualifiers, and finishing words.

samples/Opal · high confidence

A new example file (example.djs) has been added to the samples/Dogescript directory, demonstrating the Dogescript syntax and module export structure.

samples/Dogescript · high confidence

A new sample file (or-constraint.ecl) has been added to the ECLiPSe samples directory, demonstrating constraint logic programming features such as the 'or' operator and integer constraint libraries.

samples/ECLiPSe · high confidence

A new Embedded Crystal (ECR) template sample has been added to the HTML+ECR directory. The file demonstrates conditional rendering by displaying a personalized greeting if a name variable is present, or a generic greeting otherwise.

samples/HTML+ECR · high confidence

The samples/EQ directory now includes three new example files demonstrating the EQ programming language. HTTPServerVirtualHostListener.eq provides a server-side implementation for handling HTTP virtual hosts via local sockets on POSIX systems. SEButtonEntity.eq defines UI components for image-based and text-based buttons with hover/press state handling. String.eq offers utility functions for string conversion, formatting, and collection operations.

samples/EQ · high confidence

Added a new Eiffel sample application in the samples/Eiffel directory that demonstrates an embedded web service running alongside a desktop UI. The application includes a main window with a built-in web browser widget that navigates to the local embedded server, which serves test pages, environment information, and file listings via HTTP endpoints.

samples/Eiffel · high confidence

Added a new sample script, \samples/Elvish/epm.elv\, which implements a package manager for the Elvish shell. This tool allows users to install and upgrade packages from Git repositories (via HTTPS) or local directories (via rsync), managing them in a dedicated library directory that respects platform-specific paths like \XDG\_DATA\_HOME\ on Linux or \LocalAppData\ on Windows.

samples/Elvish · high confidence

The samples/Emacs Lisp directory now includes new example files: a desktop configuration file (.emacs.desktop) for saving Emacs session state, a minimal script (dude.el), and a comprehensive ESS Julia mode implementation (ess-julia.el) that provides syntax highlighting, indentation, and inferior Julia process integration for .jl files.

samples/Emacs Lisp · high confidence

Added F\# sample files to demonstrate FsPickler's JSON and BSON serialization capabilities, including Combinators, JsonFormat, JsonReader, JsonSerializer, JsonWriter, and performance tests.

samples/F\# · high confidence

This change adds new sample files to the repository. In the samples/FPP directory, it introduces a set of FPP (F Prime Prime) language definitions, including component specifications (CommandDispatcher, FileDownlink), configuration instances, and a complete deployment topology wiring these components together. Additionally, it adds several Fortran source files (sample1.f, sample2.f, sample3.F, sample1.for, bug-185631.f, m\_fftw.fpp, m\_finite\_differences.fpp) to the samples/Fortran directory, providing reference implementations for legacy and modern Fortran syntax.

samples/Fortran · high confidence

New sample files have been added to the repository: two Faust DSP programs (FFT and lowCut) in the samples/Faust directory, and a Microsoft Developer Studio project file (freeglut.dsp) for building the freeglut library in the samples/Microsoft Developer Studio Project directory.

samples/Faust, samples/Microsoft Developer Studio Project · high confidence

Added a new sample directory for the Fennel programming language, including a fully functional read-eval-print loop (REPL) that supports interactive coding, local variable preservation across chunks, command-line helpers (such as reload, reset, and completion), and a comprehensive utility module providing table manipulation functions and Abstract Syntax Tree (AST) node definitions for symbols, lists, and expressions.

samples/Fennel · high confidence

Added FlatBuffers schema definition files (\Message.fbs\ and \reflection.fbs\) to the samples directory. \Message.fbs\ defines the data structures for Arrow IPC messages, including record batches, dictionary encoding, and compression metadata, while \reflection.fbs\ provides a schema for representing parsed FlatBuffers schemas at runtime.

samples/FlatBuffers · high confidence

Added a new set of Fluent (\.ftl\) sample files in the \samples/Fluent\ directory, including \simple.ftl\, \call\_expressions.ftl\, \callee\_expressions.ftl\, \select\_indent.ftl\, and \gecko\_strings.ftl\. These files provide examples of Fluent syntax for function calls, argument handling, selector indentation styles, and Firefox-specific brand strings, serving as reference material for the Fluent localization format.

samples/Fluent · high confidence

Added several new FreeBASIC source files to the samples directory, including a WinGUI template demonstrating Windows API usage, an array object clearing utility, an intermediate representation (IR) core module, and a script for generating NSIS installer packages.

samples/FreeBASIC · high confidence

Added a new Futhark sample file (gaussian\_blur.fut) in the samples directory that demonstrates how to implement a Gaussian blur using stencil computations. The sample includes a Python wrapper for reading and writing PNG images, illustrating how to compile and run Futhark code using the PyOpenCL backend.

samples/Futhark · high confidence

New GAML sample files have been added to the samples/GAML directory, providing example models for users. These include a 3D tutorial with moving agents, a BDI (Belief-Desire-Intention) agent simulation involving miners and police, two disease spread models (incremental GIS and luneraysFlu) simulating infection dynamics on road networks, a predator-prey ecological simulation, and a road traffic model showing people commuting and road degradation.

(repo-wide) · high confidence

The samples/GAP directory now includes example files for the GAP language, providing users with reference implementations. This includes a comprehensive AutoDoc package (Magic.gd, Magic.gi) for generating package documentation, a sample package definition (PackageInfo.g) for the 'cvec' library, and basic declaration/implementation templates (example.gd, example.gi). Additionally, test files (bugfix.tst, factor.tst) and vector space library sources (vspc.gd, vspc.gi) are added to demonstrate GAP syntax and functionality.

samples/GAP · high confidence

The Git Commit language sample now includes two new filename examples: .gitmessage and COMMIT\_EDITMSG. The .gitmessage file provides a template for structured commit messages, enforcing a 72-character line limit and supporting conventional commit tags (feat, fix, refactor, chore) along with a section for documenting breaking changes. The COMMIT\_EDITMSG file serves as a sample of a standard commit message editor content, illustrating how staged and unstaged changes are typically displayed.

samples/Git Commit · high confidence

A new sample directory for the Gleam programming language has been added, providing reference implementations for common patterns. This includes a module for decoding GitHub contributor JSON data into Gleam types and a module demonstrating WebSocket connectivity using the \gun\ library for connection management, frame handling, and upgrade protocols.

samples/Gleam · high confidence

Added new Glimmer TypeScript (.gts) sample files to demonstrate component patterns. The \class.gts\ file provides a usage example for a time picker component (\BoxelInputTime\) integrated with ember-freestyle for documentation, while \template-only.gts\ introduces a template-only \ResourceCard\ component that displays resource details using Tailwind CSS classes and Heroicons.

samples/Glimmer TS · high confidence

The samples/Go directory now includes several new Go source files that are generated by various code-generation tools. These include api.pb.go (generated by protoc-gen-gogo from Protocol Buffers), embedded.go (generated by go-bindata to embed UI assets), gen-go-linguist-thrift.go (generated by the Thrift compiler), and oapi-codegen.go (generated by oapi-codegen from an OpenAPI spec). These additions provide examples of Go code produced by these specific generators for detection or testing purposes.

samples/Go · high confidence

Added a new Grammatical Framework sample demonstrating the 'Foods' abstract grammar with concrete implementations for over 20 languages, including Afrikaans, Amharic, Bulgarian, Catalan, Chinese, Czech, Dutch, English, Esperanto, Finnish, French, German, Hebrew, Hindi, Icelandic, Italian, Japanese, Latvian, Maltese, Mongolian, Nepali, Oriya, Persian, Portuguese, Romanian, Spanish, Swedish, Thai, Tswana, and Turkish. The sample includes an abstract definition of food-related categories and a shared interface (FoodsI) for languages with complex syntax, ensuring correct UTF-8 encoding across all language resources.

samples/Grammatical Framework · high confidence

The samples/GraphQL directory now includes example GraphQL files to demonstrate schema definitions and query structures. This adds kitchen-sink examples for both standard .graphql and SDL .graphqls extensions, covering queries, mutations, subscriptions, and type definitions, along with a Magento-specific schema sample illustrating product and category data models.

samples/GraphQL · high confidence

Added sample files in the samples/HCL directory to provide reference content for HashiCorp Configuration Language (HCL) and its variants. The new samples include example.hcl, example.tf, main.tf, and terraform.tfvars for Terraform; example.nomad for Nomad; example.tofu for OpenTofu; and main.workflow for Workflow definitions. These files serve as examples for syntax highlighting and language detection.

samples/HCL · high confidence

New sample configuration files have been added to the HOCON samples directory to demonstrate standard setups. The \application.hocon\ file provides a template for a Play Framework application, including module registrations, service endpoints, and feature flags. Additionally, \stream-collector.hocon\ offers a configuration example for an Akka-based stream collector, detailing network interfaces, cookie handling, and NSQ sink settings. The directory also includes \.scalafmt.conf\ and \.scalafix.conf\ to define code formatting and linting rules for Scala projects.

samples/HOCON · high confidence

The samples/HTML directory now includes new example files to demonstrate various HTML-related formats and frameworks. This adds an HTML Application (HTA) sample for Windows-based UI tools, an XHTML 1.0 Strict example, a Hoplon-based ClojureScript interactive demo, and documentation pages generated by Doxygen and pkgdown. Additionally, new .inc files are provided as HTML snippets for inclusion in other documents.

samples/HTML · high confidence

Added sample HXML build scripts for the checkstyle and vshaxe projects. The checkstyle sample configures the build to include mcover for unit test coverage and defines commands to run the analysis using Neko. The vshaxe sample provides a build configuration for the VS Code extension, specifying source paths, dependencies, and compilation targets for the JavaScript build script.

samples/HXML · high confidence

Added sample Haml template files to the samples/Haml directory, including a button interface template (buttons.html.haml.deface) for page actions and a basic greeting template (hello.haml).

samples/Haml · high confidence

Added new sample files in the samples/Hare directory, including contains.ha, iter.ha, and types.ha. These files provide reference implementations for string operations (contains, hasprefix, hassuffix), a custom format string iterator, and core filesystem types (error handling, file modes, stat structures, and directory entries) in the Hare programming language.

samples/Carbon, samples/Hare · high confidence

The samples/HolyC directory now includes several demonstration files: GrAsm.HC provides low-level graphics assembly routines, OnceDemo.HC shows how to queue commands for execution on the next reboot, Prompt.HC demonstrates interactive command-line input for integers, floats, strings, and dates, RandDemo.HC illustrates random number generation and seeding behavior, and Spy.HC offers utilities for inspecting task stacks and call frames.

(repo-wide) · high confidence

New sample applications are now available in the \samples/hoon\ directory. The \canvas.hoon\ file introduces a peer-to-peer drawing application that manages state via Gall agents, handles user actions like painting and joining, and integrates with the file server and launch store. The \eyre.hoon\ file provides a lighter-weight HTTP server implementation, defining internal data structures for request handling, bindings, channels, and timeouts, along with utilities for managing event queues and acknowledgments.

samples/hoon · high confidence

New sample files have been added to the IGOR Pro samples directory to demonstrate code highlighting capabilities. The CodeBrowser.ipf module provides a code browser panel with menu integration, parsing logic for structures and variables, and HTML generation for documentation comments. Supporting files functions.ipf and generic.ipf provide example procedures and constants for testing the highlighting engine.

samples/IGOR Pro · high confidence

New ISPC (Intel SPMD Program Compiler) sample files have been added to the samples/ISPC directory, providing reference implementations for parallel programming. These include VideoFunctions.ispc for video effect processing, program\_city.ispc for a Shadertoy-style city ray tracer, and volume.ispc for volumetric ray marching with density interpolation.

samples/ISPC · high confidence

A new sample application demonstrating the Imba programming language has been added to the samples directory. The file \samples/Imba/main.imba\ implements Conway's Game of Life as a terminal-based application, featuring a 97-line script that handles board initialization, neighbor counting, generation ticking, and terminal screen management (including cursor hiding and alternate screen buffer switching).

samples/Imba · high confidence

New sample files for the J programming language have been added to the repository. This includes a 'hashbang' script demonstrating a basic 'Hello, GitHub!' execution via jconsole, and 'stwij.ijs', a comprehensive example implementing data processing logic (such as employee hours, earnings, and tax calculations) based on the 'Continuing to write in J' tutorial.

samples/J, samples/jq · high confidence

Added two new JSONiq sample scripts in the samples/JSONiq directory: detail.jq, which retrieves a specific database entry by ID and part, and query.jq, which searches the catalog database for keywords with a configurable result limit. These samples demonstrate how to import and use the http-request, index, and catalog modules to interact with the guide.com services.

samples/JSONiq · high confidence

A new base layout template (baseLayout.jte) has been added to the Java Template Engine sample. This file provides a standard HTML5 structure that automatically includes global CSS and JavaScript bundles, language-specific translations, and specific UI libraries like jQuery, Bootstrap, and Sentry, serving as a reusable foundation for other pages in the sample application.

samples/Java Template Engine · high confidence

Added several new Java sample files to the repository, including \FieldGen.jsh\ (a JShell script for generating finite field implementations), \GrammarKit.java\ (a GrammarKit-generated parser), \JFlexLexer.java\ (a JFlex-generated lexer), \ProtocolBuffer.java\ (a Protocol Buffer generated class), and various utility and service classes for Nokogiri, Hudson, and Clojure. Additionally, the \.jsh\ file extension was added to the Java language definition to ensure proper syntax highlighting for JShell scripts.

samples/Java · high confidence

Added sample grammar files for Jison and Jison Lex parsers, including a ClassyLang grammar and lexer, an ANSI C grammar, a regex lexer grammar, and a Jison Lex parser definition. These samples demonstrate how to define lexical rules and parsing logic using the Jison parser generator.

samples/Jison, samples/Jison Lex · high confidence

A new KV language showcase sample has been added to the samples/kvlang directory, providing a demonstration of Kivy's KV language features including custom widget definitions, action bars, screen management, and code highlighting.

samples/kvlang · high confidence

The samples/KakouneScript directory now includes a complete sample configuration for the Kakoune editor. This adds syntax highlighting, indentation, and file-type detection for C, C++, and Objective-C files via c-family.kak. It also introduces a documentation system (doc.kak) that renders AsciiDoc files into a scratch buffer with syntax highlighting, link following, and anchor jumping, accessible via the :doc command. Finally, a sample kakrc (filenames/kakrc) is provided demonstrating a configured environment with color schemes, tab settings, status bar options, and clipboard mappings.

samples/KakouneScript · high confidence

New sample scripts have been added to the repository to demonstrate usage of the Kerboscript and Kickstart languages. The Kerboscript samples include a SpaceX-style hoverslam landing script, a standard launch sequence with countdown and staging, and a PID controller library (noted as superseded by the built-in PIDloop function). The Kickstart samples provide Fedora installation configuration templates, including a Fedora Jam XFCE live image setup and MySQL/Cobbler integration examples.

(repo-wide) · high confidence

The repository now includes a collection of sample KiCad design files in the 'samples/KiCad Schematic' directory. These additions provide reference designs and component definitions for users, including a new KiCad symbol library file (Regulator\_Current.kicad\_sym) defining hot-swap current limiter controllers, and multiple schematic files (such as buttons.sch, buzzer.sch, and rpi-cm4-carrier-template.kicad\_sch) covering circuits like the Poncho Simon EDU-CIAA, a Raspberry Pi Compute Module 4 carrier template, and various other hardware examples.

samples/KiCad Schematic · high confidence

New sample files have been added to the Kusto directory, including a KQL script for analyzing Azure AD consent and permission grants, and several CSL scripts providing example queries for Service Fabric trace logs, storage tables, and performance counters.

samples/Kusto · high confidence

Added sample TableGen (.td) files that define the structure and interfaces for several MLIR dialects, including AMDGPU (base, attributes, enums, types), PTX (BasicPtxBuilderOpInterface), LLVM (LLVMDialect), and Math (MathBase). These files provide the declarative definitions for dialects, operations, types, and attributes used in the LLVM/MLIR ecosystem.

samples/LLVM TableGen · high confidence

Added new LabVIEW sample projects and libraries to the repository, including the Actor Framework Fundamentals simulation, Malleable VIs basics and nested examples, and a PL Modbus Client class. These additions also introduce support for the .lvclass file extension in the project structure.

samples/LabVIEW · high confidence

A new Lean 4 sample file, BirthdayProblem.lean, has been added to the samples directory. It provides a formal proof of the Birthday Problem using Lean 4 and Mathlib, demonstrating both a combinatorial approach via finite type cardinalities and a probabilistic approach using measure theory.

samples/Lean 4 · high confidence

Added two new sample files in the Lean directory: binary.lean, which defines general properties of binary operations (such as commutativity, associativity, and distributivity) and proves related theorems, and set.hlean, which defines a precategory and category structure for sets using homotopy type theory concepts.

samples/Lean · high confidence

A new sample file (contents.lr) has been added to the Markdown samples directory, demonstrating the use of the .lr extension for Lektor content files. This file contains a blog post about the Spyder IDE project, including metadata and body content, serving as an example of how Lektor-style content can be represented within the Markdown sample set.

samples/Markdown/filenames · high confidence

Added four new sample programs in the Leo language for the Aleo platform: a Fibonacci calculator, a group coordinate operations example, a twoadicity calculator, and a private voting system with proposal management.

samples/Leo · high confidence

Added a collection of MATLAB scripts in the samples/MATLAB directory that demonstrate various computational methods, including Lagrangian coherent structures (FTLE) for the restricted three-body problem, bicycle dynamics modeling, and structural system identification.

samples/MATLAB · high confidence

New MLIR sample files have been added to the samples/MLIR directory to support testing and demonstration of the compiler infrastructure. const-fold.mlir provides test cases for constant folding operations across TensorFlow Lite dialects, including arithmetic (add, sub, mul) and unary operations on float and integer tensors. core-ops.mlir contains examples of standard MLIR operations such as arithmetic, comparisons, and control flow. executor\_to\_control\_dialect.mlir demonstrates the conversion of TensorFlow executor graphs to the control dialect, specifically handling loop structures and control dependencies. sample.mlir serves as a general reference for MLIR syntax features including function definitions, block structures, and location information.

samples/MLIR · high confidence

Users can now use the Macaulay2 language. This change adds a sample file (FGLM.m2) demonstrating the FGLM algorithm for computing Groebner bases via the FGLM algorithm.

samples/Macaulay2 · high confidence

Added sample files to demonstrate Makefile syntax highlighting and dependency generation features. The \file-icons.make\ file provides a comprehensive example of a Makefile used for generating web fonts and managing icon assets, showcasing various Makefile constructs and targets. The \foo.o.d\ file demonstrates dependency file syntax, while the \makefile\ file shows a basic recursive make setup.

samples/Makefile · high confidence

Added a collection of Mercury source files to the samples directory to support language detection and verification of new heuristics. The new files include a 'Hello World' example, parser definitions, and various utility and algorithm implementations such as mutable stores, polymorphism handling, and ROT13 encoders.

samples/Mercury · high confidence

New sample files have been added to demonstrate the Monkey C and Win32 Message File languages. The Monkey C sample includes a VesselModel.mc file featuring a StartTimer class with countdown, synchronization, and adjustment logic, along with associated unit tests. The Win32 Message File sample provides a logmess.mc file defining application message resources for warnings, errors, and informational events.

samples/Monkey C, samples/Win32 Message File · high confidence

Added MoonBit sample files to the samples directory, including benchmark implementations (constant folding, symbolic differentiation, FFT, N-queens, and red-black tree) and configuration files (moon.mod and moon.pkg) for the async library.

samples/MoonBit · high confidence

New sample files have been added to the Motorola 68K Assembly directory, providing reference implementations for common tasks and system interactions. These include optimized memory routines (bls\_routines.inc), CPU and memory detection logic (cpu.s), IFF/ILBM image processing (iff\_ilbm.i), an LZ4 decompressor (lz4.X68), a comprehensive ROM testbench (rom\_testbench.asm), and low-level system initialization and restoration code (system.s).

(repo-wide) · high confidence

Added a new sample file (categories\_to\_columns.mtml) in the samples/MTML directory that demonstrates how to use Movable Type Markup Language to dynamically render categories into a multi-column layout.

samples/MTML · high confidence

The application now supports the NEON configuration format. A default configuration schema (config.neon) has been added, defining parameters for autoloading, analysis levels, feature toggles, parallel processing, and error reporting, along with the necessary extension registrations. An example configuration file (example.neon) is also provided to demonstrate usage with PHP settings, database connections, and user lists.

samples/NEON · high confidence

Added sample NSIS (Nullsoft Scriptable Install System) installer scripts to the samples directory. The new files include bigtest.nsi, a comprehensive test script exercising installer features like registry operations, INI file handling, branching logic, and UI customization, and x64.nsh, a header file providing macros for detecting 64-bit environments and managing file system redirection.

samples/NSIS · high confidence

Added six new NWScript files to the samples directory to demonstrate specific gameplay logic: handling trap disarm and unlock events with kobold reactions, managing a carrion crawler death animation and dialogue flags, triggering encounter text for plague bodies, spawning spiders from a nest, and controlling a Phantasmal Image cutscene.

samples/NWScript · high confidence

Added sample Nginx configuration files to the samples directory, including a comprehensive virtual host example (example.com.vhost) with SSL and security settings, a main configuration file (nginx.conf) demonstrating reverse proxy and load balancing setups, and a test configuration (sample.nginx) for proxy and alias behaviors.

samples/Nginx · high confidence

Added sample files for the Nim programming language, including a build configuration script (config.nims) for static binaries with musl, a compiler configuration file (nim.cfg) with cross-platform settings, a maintenance script (foo.nim), a demonstration file (main.nim) showcasing language features like new number literals, and a specific configuration (nimfix.nim.cfg).

samples/Nim · high confidence

Added two new Nushell scripts to the samples directory: \release-pkg.nu\, which automates the building, packaging, and archiving of Nushell binaries for various operating systems and architectures (including Windows MSI support), and \this\_week\_in\_nu.nu\, which queries the GitHub API to generate a summary of merged pull requests for the Nushell ecosystem over the past week.

samples/Nushell · high confidence

The samples/OCaml directory now includes a collection of OCaml source files demonstrating various language features and library integrations. These additions include a continuation-passing style (CPS) utility module (Foo.ml), a command-line argument parsing library (cmdliner.ml), common utility functions (common.ml), POSIX date handling via Ctypes (date.ml), an Ocsigen web framework example (example.eliom), a balanced binary search tree implementation (map.ml), a Mirage unikernel builder (mirage.ml), a compiler reload pass for AMD64 (reload.ml), POSIX signal set wrappers (sigset.ml), and a Unicode text processing library (uutf.ml).

samples/OCaml · high confidence

A new sample class (Sample.Person.cls) has been added to the ObjectScript samples directory, demonstrating persistent classes, indexes, embedded objects, and SQL queries for the InterSystems ObjectScript language.

samples/ObjectScript · high confidence

The samples/Objective-C directory now includes source files for several third-party libraries (ASIHTTPRequest, JSONKit, SBJson) and sample application components (Foo, MainMenuViewController, PlaygroundViewController, Siesta). This provides reference implementations and headers for Objective-C development within the samples area.

samples/Objective-C · high confidence

Added sample files for the Odin programming language, including a basic syntax example in samples/Odin/sample.odin and an openEHR BMM schema instance in samples/Object Data Instance Notation/openehr\_ehr\_1.0.3.bmm.odin, enabling users to reference Odin code structures and data formats.

samples/Object Data Instance Notation, samples/Odin · high confidence

Added four new Rego policy samples for Open Policy Agent covering HTTP API authorization, Kafka access control, Kubernetes admission control, and SSH authorization.

samples/Open Policy Agent · high confidence

Added two new OpenCL kernel source files to the samples directory: fft.cl, which provides a function for performing 1D FFTs using the FFTW library, and sample.cl, which contains a basic kernel demonstrating local memory barriers and arithmetic operations.

samples/OpenCL · high confidence

Added a new sample directory for OpenEdge ABL containing a complete email-sending implementation. This includes an Email class for managing message components (senders, recipients, attachments), a SendEmailAlgorithm interface using the Strategy pattern, utility classes for date and base64 encoding, and supporting scripts for socket communication and execution.

samples/OpenEdge ABL · high confidence

A new OpenQASM 2.0 sample file (half\_adder.qasm) has been added to the samples directory, providing a reference implementation of a half-adder quantum circuit for users to study or run.

samples/OpenQASM · high confidence

A new OpenRC runscript has been added for the acpid daemon, enabling users to manage the Advanced Configuration and Power Interface service via OpenRC. The script configures the daemon to start after localmount, optionally uses the logger, and supports a reload command to send a HUP signal for configuration updates.

samples/OpenRC runscript · high confidence

This change introduces three new sample files in the samples/Ox directory: IJCEmet2009.oxh, which implements the Imai, Jain and Ching Econometrica 2009 model; ParallelObjective.ox, which provides client and server classes for parallel optimization using CFMPI; and particle.oxo, which implements a particle filter log-likelihood calculation. These additions provide users with reference implementations for specific econometric models, parallel computing patterns, and state-space filtering techniques within the Ox framework.

samples/Ox · high confidence

New PDDL (Planning Domain Definition Language) files have been added to the samples directory, providing concrete examples for planning scenarios. This includes a search-and-rescue domain and problem file defining drone operations for delivering supplies, as well as a floor-tile cleaning domain illustrating robot movement and cleaning actions on a grid.

samples/PDDL · high confidence

New sample grammar files have been added to the PEG.js samples directory: \abnfp.peggy\ implements an ABNF parser supporting rules, alternations, repetitions, and numeric character values, while \rfc5988.pegjs\ provides a parser for RFC 5988 Link headers. These files serve as reference implementations for parsing these specific syntaxes using PEG.js.

samples/PEG.js · high confidence

The samples/Pan directory now includes a collection of new .pan template files demonstrating the Pan configuration language. These samples cover various infrastructure components, including Ceph storage (ceph-raid, infernalis, osd-fetch, simple), OpenNebula integration (onevm, resources, mysql), DCACHE configuration (link, unit), Nagios monitoring (cluster-A), and utility templates for database mappings, functions, and data types.

samples/Pan · high confidence

Added several sample files for the Pawn programming language to the samples/Pawn directory, including Checkpoint Manager logic (Check.inc), fixed-point arithmetic utilities (fixed.inc), SA:MP function patches (fixes.inc), a TimeLeft plugin implementation (foo.sma), file management helpers (mfile.inc), a timer test script (timertest.pwn), and a unit testing framework (y\_testing.inc).

(repo-wide) · high confidence

Added a new set of sample programs in the Pep8 assembly language under the samples/Pep8 directory. These examples demonstrate various programming concepts and algorithms, including integer division (div.pep), flag manipulation (flag.pep), linked list operations (linked.pep), magic square validation (msq.pep), quicksort implementation (qsort.pep), string buffer management (stri\_buf.pep), and stack-based string input/output (stristack.pep).

samples/Pep8 · high confidence

Added sample game files for Planetfall (ZAP format) and The Hitchhiker's Guide to the Galaxy (ZIL format), providing users with reference implementations and playable examples of these classic interactive fiction titles.

samples/ZAP, samples/ZIL · high confidence

Added several new PlantUML diagram files to the samples directory, including examples for class structures, Azure architecture boundaries, use cases, and sequence flows. These samples provide reference templates for users to understand and create their own diagrams.

samples/PlantUML · high confidence

Added sample files for PostCSS (sample.pcss, sample.postcss) and SugarSS (sample.sss) to the samples directory, demonstrating syntax features such as mixins, variables, nesting, and utility class application.

samples/PostCSS · high confidence

Added two new Power Query (M) files in the samples/Power Query directory: fnMxToolboxLookup.pq, which calls the MXToolbox API to retrieve and normalize DNS/endpoint lookup data into a canonical schema, and q\_MxToolboxScore\_SOAR3.pq, which computes a deterministic risk score and assigns a reputation tier (Clean, Degraded, HighRisk, or Malicious) based on the lookup results.

samples/Power Query · high confidence

Added three new Praat script samples to the repository: dynamicity.praat, which calculates a moving average across a TextGrid; queryTable.praat, which queries formant data from sounds aligned with TextGrids and exports the results to a table; and randomiseArticles.praat, which appears to be a duplicate of the queryTable script.

samples/Praat · high confidence

A new Procfile has been added to the samples directory, defining five distinct process types (web, worker, cron, smtp, requeuer) that specify the commands required to run the application components using Bundler and Puma.

samples/Procfile · high confidence

New sample files have been added to the samples/PureScript directory, demonstrating core PureScript libraries and a reactive UI example. The samples include implementations for Control.Arrow (arrow combinators), Data.Foreign (JSON parsing and foreign data handling), and Data.Map (binary search tree map operations). Additionally, ReactiveJQueryTest.purs provides a complete example of building a reactive web application with jQuery, featuring two-way data binding for forms, a dynamic todo list with array bindings, and computed properties.

(repo-wide) · high confidence

Added a new Pyret language sample implementation in samples/Pyret, providing a command-line interface for compiling, running, and serving Pyret programs. Users can now build standalone runnable JavaScript bundles, compile modules, or start a local server, with options for type-checking, profiling, and customizing build outputs.

(repo-wide) · high confidence

New QuakeC source files have been added to the samples directory, introducing two new entity types for game development. The \slider.qc\ file implements a \func\_slider\ entity that moves between two points, supporting features like crush damage, constant damage, and sound effects, with logic to handle blocking and state changes. The \spawner.qc\ file implements a \monster\_spawner\ entity that spawns various monster types (such as zombies, demons, and knights) upon use, allowing configuration for angry mode, no-teleport-flash effects, and specific monster attributes.

samples/QuakeC · high confidence

Added new Quint specification files in the samples/Quint directory, including LamportMutex.qnt, Paxos.qnt, and clockSync6.qnt. These files provide formal models for Lamport's distributed mutual-exclusion algorithm, the Paxos consensus algorithm, and a clock synchronization algorithm, allowing users to explore and verify these distributed systems using the Quint tool.

samples/Quint · high confidence

A new sample file (example.rascript) has been added to the samples/RAScript directory, demonstrating the RAScript language syntax with a specific implementation for the game Battle City (ID 4111). This file defines rich presence logic for displaying the current stage and includes an achievement definition for clearing World 1, serving as a reference for users writing similar scripts.

samples/RAScript · high confidence

Added four new REXX scripts to the samples/REXX directory: BatchRemapBrushes.pprx, which recursively processes image files to generate sprite sheets and constant tables; ShapesInfo.rexx, which displays detailed metadata and optional visual previews of Blitz Basic .shapes files; SkrivShape.rexx, which writes binary shape header data for custom graphics; and ag2xml.rexx, which converts Amiga guide text files into XML format.

samples/REXX · high confidence

The samples/ROS Interface directory now includes a set of standard ROS message, service, and action definitions (including AboutROSInterfaces, LoadMap, Marker, NavigateThroughPoses, and ParameterDescriptor) to serve as reference implementations for interface structures.

samples/ROS Interface · high confidence

The repository now includes sample files and documentation for the RUNOFF language in the samples/RUNOFF directory. This addition provides reference material for the RUNOFF markup format, including help files for VMS utilities like ZIP and MCP, documentation for the LONGLIB graphics library, and contributor guidelines for the Linguist project, enabling better detection and highlighting of RUNOFF files.

samples/RUNOFF · high confidence

The samples/Raku directory now contains a collection of Raku source files and test scripts, including implementations for Term::ANSIColor, Bailador, LWP::Simple, and Math::Model, alongside various specification tests for language features like Date/DateTime handling, exception management, and list operations.

samples/Raku · high confidence

A new sample project has been added for the ReScript programming language, featuring a complete implementation of a Red-Black Tree data structure. The sample includes the source file \RedBlackTree.res\ and its corresponding interface file \RedBlackTree.resi\, demonstrating the language's syntax and type system through a functional algorithm example.

samples/ReScript · high confidence

Added sample Rez resource files (Rezilla\_DITL.r, dialog.r, gui\_mac.r) to the samples/Rez directory, providing definitions for Mac OS navigation dialogs, a generic dialog with standard controls, and application versioning resources for Carbon-based GUI applications.

samples/Rez · high confidence

Added two new sample components for the Riot.js framework: a live-filtering component that fetches currency exchange rates and allows users to search them in real-time, and a todo-list component that supports adding new items and toggling their completion status.

samples/Riot · high confidence

Added sample Robot Framework test files (data\_driven.robot, gherkin.robot, keyword\_driven.robot) and a resource file (keywords.resource) to the samples/RobotFramework directory, providing examples for data-driven, keyword-driven, and Gherkin-style testing approaches.

samples/RobotFramework · high confidence

The Ruby samples directory now includes files for newly supported extensions and generated code patterns, such as \.rbi\ (Sorbet), \.prawn\ (PDF generation), \.jbuilder\ (JSON views), \.fcgi\ (FastCGI scripts), \.spec\ (RSpec tests), and \.rabl\ (RABL templates). It also adds samples for code generated by tools like Racc, protoc-gen-twirp, and Thrift, as well as real-world executables for JRuby and Rubinius, ensuring these file types are correctly identified and highlighted.

samples/Ruby · high confidence

This change adds several Rust code samples to the \samples/Rust\ directory, including a \base64url\ script using \rust-script\, a \hashmap\ implementation, a \main.rs\ demonstrating \extern crate\ usage, and a \task.rs\ file illustrating task management. Additionally, Rust lexing support is turned on, allowing the system to recognize and highlight Rust code.

samples/Rust · high confidence

Added sample files for the SIP language bindings specification. In samples/Quartus Simulation IP, new .sip files define Quartus simulation IP components (DDR3, PLL, ADC) by specifying their tool versions, libraries, and associated source files. In samples/SIP, new .sip files provide Python bindings for the pywpsrpc library, including type mappings, COM interface wrappers, and core module definitions.

samples/Quartus Simulation IP, samples/SIP · high confidence

Added several new SMT-LIB 2.0 and Z3-specific sample files to the samples/SMT directory, including benchmarks for array reasoning (as-left.z3), large integer arithmetic (bignum\_lia1.smt2), list structures (list4.smt2), the 10-queens problem (queen10-1.smt2), and vector shuffle operations (shufflevector.smt). These files provide concrete examples of various SMT logics and problem types for users to reference or test against.

samples/SMT · high confidence

New Scala sample files have been added to the repository, including a '99 bottles of beer' script, a 'Hello World' script, and a Scala worksheet demonstrating futures. Additionally, several Kojo-specific examples (car-ride, fib-tree, turtle-controller) are now included with the .kojo file extension, supporting interactive graphics and turtle drawing.

samples/Scala · high confidence

New sample scenarios have been added to the samples/Scenic directory, providing examples for both autonomous driving and planetary rover simulation. The driving samples (bypassing.scenic, composition.scenic, driving\_model.scenic) demonstrate lane-changing behaviors, compositional scenario structures, and the underlying driving world model using OpenDRIVE maps. The mars.scenic sample illustrates a rover navigation task through a debris field with a bottleneck, utilizing the Webots simulator interface.

samples/Scenic · high confidence

A new Singularity container definition file has been added to the samples directory, providing a pre-configured environment for RStudio Server (version 1.2.5033). This container image includes RStudio Server along with LDAP authentication support, allowing users to deploy and run RStudio within a Singularity containerized environment.

samples/Singularity · high confidence

New Slang shader samples have been added to the repository, providing reference implementations for GPU-based texture processing and differentiable rendering. The collection includes compute shaders for building mip-map layers via box filtering, converting buffers to mip-maps, and propagating gradients between mip levels. Additionally, a differentiable texture struct is introduced, enabling hardware-accelerated primal texture sampling with software-based backward pass differentiation for linear and trilinear filtering, supporting gradient accumulation through fixed-point atomics.

samples/Slang · high confidence

The samples/Slice directory now includes .ice files (Murmur.ice, Test.ice, testSlice01.ice), enabling the application to recognize and provide syntax highlighting for the Slice language. This change disambiguates .ice files from JSON, ensuring they are treated as Slice definitions rather than JSON data.

samples/Slice · high confidence

New sample files containing Smalltalk source code (specifically Boolean and Collection class definitions from Pharo 4.0) have been added to the samples/Smalltalk directory. These files provide reference implementations for core language constructs, allowing users to explore or integrate Smalltalk-style logic within the project.

samples/Smalltalk · high confidence

A new Smithy model file (weather.smithy) has been added to the samples directory, defining a Weather service that exposes City resources with read and list operations, including a CityId string with a specific pattern validation.

samples/Smithy · high confidence

The application now recognizes SourcePawn as a distinct programming language, enabling syntax highlighting and language-specific features for .sp and .inc files. This change includes adding sample SourcePawn files, such as the Bunnyhop Statistics API (bhopstats.inc), shavit's Timer (shavit.inc), and the SourceMod MapChooser plugin (foo.sp), which serve as examples of the language's syntax and structure within the samples directory.

samples/SourcePawn · high confidence

Added two new SpiceDB schema files to the samples directory: \oviva.zed\, which defines a permission model for a healthcare platform with roles like patients, coaches, and various administrators, and \schema.zed\, which provides a comprehensive RBAC schema for Red Hat Hybrid Cloud Console covering resources such as hosts, notifications, and cost management.

samples/SpiceDB Schema · high confidence

Added SuperCollider source files (.sc and .scd) to the samples directory, including the core WarpTate, WarpTrack, WarpPreset, and WarpUtil classes for managing MIDI tracks, presets, and sensor calibration, along with an example script demonstrating basic synthesis.

samples/SuperCollider · high confidence

A new TodoMVC sample application has been added for the Svelte framework, providing a reference implementation of the standard todo list functionality. Users can now view or utilize this sample to see how to build a reactive, state-managed UI with Svelte, including features like adding, editing, and deleting todos, filtering by status, and persisting data to local storage.

samples/Svelte · high confidence

Added new sample files in the samples/TL-Verilog directory, including a calculator kernel demonstrating basic arithmetic operations and a WARP-V processor configuration for RISC-V, providing reference implementations for users exploring TL-Verilog designs.

samples/TL-Verilog · high confidence

A new Tabular Model Definition Language (TMDL) file has been added to the samples directory, defining the 'Current page' table. This definition includes measures for dynamic drill-through button text and tooltips, a string column for the page name, and an import-mode partition with source data that replaces 'Engine activity' with 'Engine activities'.

samples/TMDL · high confidence

A new sample regression test script (regtest\_nmmnest.csh) has been added to the Tcsh samples directory. This script tests the bit-for-bit reproducibility of the WRF model by comparing single processor serial runs to OpenMP and MPI parallel runs, handling input acquisition via CVS, file arguments, or environment variables.

samples/Tcsh · high confidence

New sample files have been added to the Terraform Template directory to demonstrate template usage. The donors.tftpl file provides a JSON structure for donor information with placeholders for name, email, and mailing address, while policy.tftpl illustrates an AWS IAM policy structure that dynamically encodes EC2, S3, Lambda, and DynamoDB permissions.

samples/Terraform Template · high confidence

A new sample file (.tm\_properties) has been added to the TextMate Properties samples directory, providing a reference configuration for TextMate editors. This file defines window title formatting, directory exclusions, build variables (including Ninja targets and compiler flags), and file-type-specific settings such as tab sizes and scope attributes for C++ and Objective-C++ sources.

samples/RON, samples/TextMate Properties · high confidence

A new sample script, hanoi.sed, has been added to the samples/sed directory. This script implements the Towers of Hanoi puzzle using sed, allowing users to input ring configurations and view the step-by-step solution. It includes input validation for characters and format, and supports moving rings between three towers.

samples/sed · high confidence

Added sample TypeSpec definitions to demonstrate library usage: \samples/TypeSpec/json-schema.tsp\ defines models for generating JSON Schemas, while \samples/TypeSpec/petstore.tsp\ provides a REST API definition for a Pet Store service. Additionally, standard TSPLIB test data files (\att48.tsp\ and \dantzig42.tsp\) were added to the samples directory.

samples/TSPLIB data, samples/TypeSpec · high confidence

The samples/Unity3D Asset directory now includes a collection of Unity asset files, providing concrete examples for integration. This addition includes a material (GapTile.mat), an animation clip (Hover.anim) that scales and fades a radius element, a prefab (canvas\_Fullscreen\_Fader.prefab) for UI fade effects, a TimeManager configuration, a meta file for the Tiles folder, and an avatar mask (handFingers.mask) defining bone weights for hand animations.

samples/Literate CoffeeScript, samples/Unity3D Asset, samples/Velocity Template Language · high confidence

Added new sample projects for the Uno platform, including a 2D Pong game implementation and a physics-based Tower Block demo using Box2D, providing reference implementations for game logic and physics interactions.

samples/Uno · high confidence

Added several new VBA sample files to the samples/VBA directory, including ErrorHandling.bas for standard error management, QuickCards.bas for managing Word building blocks, WorkbookReporter.cls and specs.bas for Excel test reporting and specification suites, and various class modules (dictionary.cls, WorksheetView.cls) and forms (frmConvert.frm, stdSaveHandler.frm) demonstrating UI and data handling patterns.

samples/VBA · high confidence

New sample files have been added to the samples/Verse directory to demonstrate the Verse programming language. ConcurrencyFeatures.verse provides examples of parallel processing patterns using race, rush, and sync blocks for array operations, while Hexadecimal.verse implements utilities for converting bytes and strings to and from hexadecimal representations.

samples/Verse · high confidence

Added sample smart contracts written in the Vyper language to the \samples/Vyper\ directory, including implementations of the ERC-20 and ERC-721 token standards, a voting ballot system, a crowdfunding campaign, and a name registry.

samples/Vyper · high confidence

Added four new sample files in the samples/WDL directory to demonstrate Workflow Description Language usage: fq.wdl (FASTQ quality control and subsampling tasks), hello.wdl (a basic 'Hello World' workflow), ifs\_in\_scatters.wdl (conditional logic within scatter blocks), and passingfiles.wdl (file creation and consumption between tasks).

samples/WDL · high confidence

Added two new sample WebIDL definition files to the samples directory: AnimationEvent.webidl, which defines the AnimationEvent interface and its init dictionary for CSS animation events, and Fetch.webidl, which defines the Body interface (including methods like arrayBuffer, blob, json, and text) and the GlobalFetch interface for the Fetch API. These files serve as reference implementations for these web standards within the project's sample set.

samples/WebIDL · high confidence

New Whiley source files have been added to the samples directory, including interactive browser-based games (Conway's Game of Life and Minesweeper) that utilize the W3C DOM API for canvas rendering and event handling, alongside a standard library implementation of the Option type with support for mapping, filtering, and unwrapping.

samples/Whiley · high confidence

A new sample application named 'Wren' has been added to the samples directory. This entry point demonstrates a small text editor built using the Wren language, leveraging the 'dome' platform for windowing and input, 'graphics' for rendering, and 'io' for file system operations. The sample includes logic for loading, saving, and displaying text files with line numbers and cursor positioning.

samples/Wren · high confidence

This change introduces a new Xmake build configuration for the CHERIoT samples, allowing users to build the project using the Xmake toolchain instead of (or alongside) existing methods. The configuration sets up a custom 'cheriot-clang' toolchain targeting the RISC-V CHERIoT architecture, enforces specific compiler flags (such as -Oz optimization and C2x/C++20 standards), and defines custom rules for building CHERIoT compartments and libraries with appropriate linker scripts.

samples/Xmake · high confidence

Added a new sample configuration file (rever.xsh) for the Xonsh project, providing a ready-to-use release automation setup. This includes definitions for version bumping, changelog generation, testing, building AppImages, and publishing to PyPI and Conda Forge.

samples/Xonsh · high confidence

Added sample YARA rule files (OfExample.yar, example.yara, true.yar) to the samples directory, providing examples of YARA syntax including string matching, hex patterns, and condition logic for users to reference.

samples/YARA · high confidence

Added sample Yul smart contract files to the repository, including a basic contract structure in contract.yul and a complete ERC20 token implementation in erc20.yul, providing reference implementations for users working with the Yul assembly language.

samples/Yul · high confidence

Added three new ZModel schema files (blog.zmodel, saas.zmodel, todo.zmodel) in the samples directory, providing reference implementations for Prisma-based data models with ZenStack authorization rules. These samples demonstrate how to define database schemas, configure Prisma generators and ZenStack plugins (such as TanStack Query and SWR hooks), and implement role-based access control policies for common application patterns including blog posts, multi-tenant SaaS organizations, and collaborative todo lists.

samples/Zmodel · high confidence

Added a sample ZenScript file (sample.zs) in the samples directory that demonstrates CraftTweaker usage, including registering a custom command handler for '/ct syntax' and defining various recipe and logic examples.

samples/ZenScript · high confidence

A new Zimpl model file (sample.zmpl) has been added to the samples directory, providing a formulation of the n-queens problem using binary variables. This sample allows users to set the board size via the 'columns' parameter and demonstrates how to maximize the number of queens on the board while enforcing non-attacking constraints.

samples/Zimpl · high confidence

A new BibTeX style file, bibkeys.bst, has been added to the samples directory. This style processes bibliography entries to output only their citation keys, providing a utility for users who need to extract or list reference identifiers from their bibliographic data.

samples/BibTeX Style · high confidence

Added sample VCL configuration files for Varnish versions 2 and 3 in the samples/VCL directory. These files provide default implementations for standard VCL subroutines (such as vcl\_recv, vcl\_hash, and vcl\_fetch) that serve as fallback defaults or starting points for users configuring the cache server.

samples/VCL · high confidence

Added two new UnrealScript sample files to the repository: \MutU2Weapons.uc\, a mutator class for replacing weapons in Unreal Engine games, and \US3HelloWorld.uc\, a basic game info class that logs a message on initialization.

samples/UnrealScript · high confidence

Added two new sample files (knitr-minimal.Rnw and knitr-beamer.Rnw) to the samples/Sweave directory, providing minimal and Beamer-specific examples for using the knitr package within LyX.

samples/Sweave · high confidence

The samples/Mermaid directory now includes a collection of sample files demonstrating various Mermaid diagram types, including C4 context, class, ER, flowchart, Gantt, gitgraph, pie chart, requirement, sequence, state, and user journey diagrams. These samples provide users with concrete examples of how to structure and render different diagram syntaxes within the application.

samples/Mermaid · high confidence

A new sample theme file (mild.edc) has been added to the Edje Data Collection samples, providing a pre-configured visual style for the terminal application with specific background colors, image assets, and signal handling for focus and media states.

samples/Edje Data Collection · high confidence

The samples/Formatted directory now includes three new .for files: NiAlH\_jea.eam.fs, long\_seq.for, and wksst8110.for. These additions provide new example inputs for the Formatted language, covering scientific data (Ni-Al-H trapping), primer sequences, and weekly sea surface temperature data.

samples/Formatted · high confidence

Added sample files for the APL programming language, including a script demonstrating text generation, a unit testing framework implementation, and a hashbang script for execution.

samples/APL · high confidence

Added sample files in the samples/EdgeQL directory, including a default.esdl schema defining a Task type with text and completed properties, and a migration.edgeql script that creates the initial migration, enables the edgeql\_http and graphql extensions, and applies the schema changes.

samples/EdgeQL · high confidence

Added sample files for Erlang build tools to the samples directory, including an Emakefile for the Erlang compiler, a rebar.config for the Rebar build tool, and corresponding lock files (rebar.config.lock and rebar.lock) to demonstrate dependency resolution and locking.

samples/Erlang/filenames · high confidence

A new sample workload model file (copyfiles.f) has been added to the samples/Filebench WML directory. This script defines a Filebench Workload Model Language (WML) scenario that simulates copying files by reading from a source fileset and writing to a destination fileset, allowing users to benchmark file I/O performance using this specific pattern.

samples/Filebench WML · high confidence

The repository now includes sample files for the Fish shell, providing a \config.fish\ that sets up default field separators, search paths for functions and completions, and POSIX-compliant PATH adjustments, alongside utility scripts \eval.fish\ and \funced.fish\ that implement job-control-aware evaluation and interactive function editing capabilities.

samples/fish · high confidence

Added four new sample GTK 2.0 resource configuration files (GtkRC) to the samples directory: a detailed 'qtcurve' style definition, a standard 'gtkrc-2.0' for LXAppearance users, and specific configurations for 'lambdacat' and 'v9t9' applications. These files provide users with reference examples for customizing GTK 2.0 themes and widget styling.

samples/GtkRC · high confidence

New sample Gherkin files have been added to the samples/Gherkin directory to demonstrate usage. The resources.story file provides a template for defining features, prologues, and parametrized scenarios with examples, while the tables.feature file illustrates how to handle tabular data within scenario steps for a todo list use case.

samples/Gherkin · high confidence

New sample templates have been added to the samples/HTML+ERB directory. The fishbowl.html.erb.deface file introduces a UI for configuring Fishbowl integration settings, including inventory fetching options and location group selection. Additionally, index.html.erb provides a paginated view for listing users with details like name, email, and chords, while index.rhtml offers a legacy-style table view for displaying patient diagnosis statistics broken down by age group and sex.

samples/HTML+ERB · high confidence

Added four new sample M3U playlist files to the samples/M3U directory to support testing of playlist parsing. These include a local audio playlist (Bolt Thrower), an HLS stream manifest (M+), and two IPTV playlists with EPG metadata for Australian (au) and general (gn) channels.

samples/M3U · high confidence

The repository now includes a collection of sample NASL scripts in the samples/NASL directory, providing detection logic for various vulnerabilities and backdoors. These samples cover cross-site scripting (XSS) in applications like CMSimple, CubeCart, and Dada Mail; backdoor detection for Bugbear.B and Hacker Defender; an Nmap wrapper for port scanning; authentication logic for Packeteer web interfaces; and utility functions for SMTP and TFTP protocols.

samples/NASL · high confidence

Added sample files for the OpenStep Property List and Glyphs formats, including a TypewriterInfo.plist configuration and a weathericons-regular.glyphs font definition, to support syntax highlighting for these file types.

samples/OpenStep Property List · high confidence

New sample files have been added to the samples/Pact directory, introducing a standard interface for fungible tokens (fungible-v1.pact) and a reference implementation of a coin contract (coin.pact). The fungible-v1 interface defines the standard capabilities and functions for token transfers, account management, and cross-chain transfers as per KIP-0002. The coin.pact file implements this interface, providing a complete example of a Kadena Coin contract with features such as gas buying and redeeming, account creation, balance queries, and secure transfer capabilities using managed capabilities.

samples/Pact · high confidence

Added sample Salt state files (eval.sls, gimp.sls, gpg4win-light.sls, openoffice.sls, top.sls, truecrypt.sls) to the samples/Salt directory, providing examples for configuring Ceph services and installing Windows applications like GIMP, Gpg4win, OpenOffice, and TrueCrypt.

samples/Salt · high confidence

Added sample image assets in X BitMap (.xbm) and X PixMap (.xpm) formats to the samples directory, including a 32x32 bitmap and several multi-color pixmap graphics.

samples/X BitMap, samples/X PixMap · high confidence

Added a collection of sample checksum files in the samples/Checksums directory to support testing and validation of checksum parsing. These samples cover multiple hash algorithms (SHA-256, SHA-512, MD5, CRC32, etc.) and various file formats including BSD-style, GNU-style, and SHA256SUMS conventions, as well as edge cases like single hashes, zero-value hashes, and files without trailing newlines.

samples/Checksums · high confidence

The samples/TSV directory now includes input data in TSV format (input.tsv) and output examples in VCF format (merged1.vcf, z.vcf), providing concrete test cases for tab-separated value and Variant Call Format processing.

samples/TSV · high confidence

A new EDN sample file (samples/edn/bigger-than-pluto.edn) has been added, providing a schema and data for solar system objects larger than Pluto. This includes attribute definitions for object name and mean radius, along with transaction data for celestial bodies such as the Sun, Jupiter, and Earth.

samples/edn · high confidence

A new sample file (linguist.srt) has been added to the samples directory to provide a concrete example of the SRecode Template language syntax. This addition supports the classification and recognition of SRecode Template files by language detection tools, ensuring they are identified as a distinct language type rather than generic text or another format.

samples/SRecode Template · high confidence

Added sample source files for ActionScript (FooBar.as, HelloWorld.as, NumberUtil.as, TextFieldUtil.as) and AngelScript (botmanager.as, payload.as) to the samples directory. These files provide reference code snippets for the respective languages, supporting language detection and highlighting features.

samples/ActionScript · high confidence

New sample files have been added to the repository to support Asymptote and LTspice Symbol schematic formats. This includes 3D graphing scripts in the samples/Asymptote directory (figarc4\_3D.asy, kappa-sawteeth.asy) and a block symbol definition in the samples/LTspice Symbol directory (random-shapes.asy).

samples/Asymptote, samples/LTspice Symbol · high confidence

Added sample files to demonstrate the CUE language and Cue Sheet formats. The CUE samples include a GitHub workflow schema definition and Kubernetes resource templates (Service, Deployment, DaemonSet, StatefulSet, ConfigMap). The Cue Sheet samples provide examples of audio track listings in the standard CUE sheet format.

samples/CUE, samples/Cue Sheet · high confidence

Added new sample files in the samples/Creole, samples/Org, and samples/RDoc directories to provide reference content for Creole, Org-mode, and RDoc markup languages. These files serve as test cases or documentation examples for parsers handling these specific lightweight markup formats.

samples/Creole, samples/Org, samples/RDoc · high confidence

Added sample files for the Noir programming language (including array operations, ECDSA signature verification, and voting logic) and Roff Manpage formats (including various man pages and macro files), enabling syntax highlighting for these file types.

samples/Roff · high confidence

Added a collection of sample PL/SQL files (including .sql, .pck, .pks, .pkb, .plsql, and .prc extensions) to the samples/PLSQL directory. These files provide representative code snippets for Oracle PL/SQL, enabling the tool to correctly identify and highlight this language in repositories.

samples/PLSQL · high confidence

This change adds a collection of sample files to the 'samples/XML Property List' directory, including an XML Property List grammar for Man pages (text.man), a SpaceCadet dark theme, a widget theme template with EJS placeholders, and various property list samples (info.plist, ff-man.plist). It also introduces syntax highlighting snippets and commands for Fortran and SQL scopes, providing reference implementations for these language features.

samples/XML Property List · high confidence

Added sample files to recognize additional Emacs Lisp-related filenames and extensions, including \.abbrev\_defs\, \.gnus\, \.spacemacs\, \.viper\, \Cask\, \Eask\, \Project.ede\, \\_emacs\, and \abbrev\_defs\. These samples allow the tool to correctly identify and syntax-highlight these specific configuration and project files used in Emacs Lisp environments.

samples/Emacs Lisp/filenames · high confidence

Added sample files to the \samples/Text/filenames\ directory to support recognition of new text file patterns, including \COPYING.regex\ for regular expression data, \README.1st\ for common readme variants, \\*.me\ files (e.g., \README.me\, \click.me\), and various Gentoo Portage mask files (e.g., \package.mask\, \use.mask\).

samples/Text/filenames · high confidence

Added sample files for FIGlet fonts (ivrit.flf), Glyph Bitmap Distribution Format (bitbuntu.bdf), and X Font Directory Index structures (encodings.dir, fonts.alias, fonts.dir, fonts.scale) to the samples directory, providing reference data for these legacy font formats.

samples/FIGlet Font, samples/Glyph Bitmap Distribution Format, samples/X Font Directory Index · high confidence

Added two sample files to the 'samples/Hosts File/filenames' directory: a minimal 'hosts' file containing standard local loopback entries, and a 'hosts.txt' file containing a blocklist of domains sourced from the NSABlocklist project.

samples/Hosts File · high confidence

The samples/Option List now includes example configuration files for common Ruby and JavaScript development tools. Specifically, it adds .ackrc, ackrc, .rspec, .yardopts, and mocha.opts to demonstrate valid option lists for ack, RSpec, YARD, and Mocha respectively, helping users understand the expected format for these tools.

samples/Option List · high confidence

Added sample .pc files for LuaJIT and Yaws in the samples/pkg-config directory, enabling these libraries to be discovered and configured via pkg-config. The LuaJIT sample specifies version 2.1.0 with Lua ABI 5.1, while the Yaws sample provides a template for the Yet Another Web Server library paths and flags.

samples/ProC, samples/pkg-config · high confidence

Added four new sample files in the 'samples/Regular Expression' directory containing pre-defined regular expression patterns for matching Emacs modelines, Vim modelines, ordinal numbers, and URLs.

samples/Regular Expression · high confidence

A new sample specification file (spec.html) has been added to the Ecmarkup samples directory, demonstrating the use of Ecmarkup's language features to document the proposed Array.fromAsync method. The file includes a complete specification draft with new abstract operations like IfAbruptCloseAsyncIterator and updated logic for AsyncBlockStart, providing a concrete example of how to author ECMAScript proposal specifications using the tool.

samples/Ecmarkup · high confidence

New sample files have been added to the HTML+EEX language support to demonstrate template usage across different syntax variants. The update includes an EEx sample for a book listing view, a HEEx sample for a live component form, and a LEEx sample for a standard form, providing users with reference implementations for these specific template styles.

samples/HTML+EEX · high confidence

Added sample files for JetBrains MPS, including the base language definition, a custom aspect model, and a sandbox solution, alongside MPS-format test data files for the Mathematical Programming System (advanced-problem.mps and afiro.mps).

samples/JetBrains MPS · high confidence

Added sample source files for the xBase programming language family (including AdvPL, Harbour, and Clipper variants) to demonstrate syntax highlighting and language detection. The new samples include a .ch header file with preprocessor directives and macros, a .prg file covering control structures, classes, and variables, and a .prw file featuring procedural logic and database interactions.

samples/Lasso, samples/xBase · high confidence

This change introduces new sample files for the AGS Script language, including a GlobalScript implementation that handles game initialization, control panel logic, and keyboard shortcuts (F5/F7/F9 for save/restore/restart), along with a KeyboardMovement module that provides both 'Tapping' and 'Pressing' movement modes for player characters.

samples/AGS Script · high confidence

A new example ASN.1 file has been added to the samples directory, demonstrating a schema for purchase orders. This sample defines structures for purchase orders, customer information, addresses, and item lists, providing a reference implementation for ASN.1 encoding rules.

samples/ASN.1 · high confidence

The samples/ATS directory now includes new example files demonstrating advanced ATS features. These include CoYonedaLemma.dats and YonedaLemma.dats, which implement the CoYoneda and Yoneda lemmas using ATS's type system and functors. Additionally, DiningPhil2.dats (along with its supporting .sats and .dats files) provides a concurrent implementation of the Dining Philosophers problem using channels and threads. Other samples include basis\_ssntype.sats for session types, csv\_parse.hats for CSV parsing, and intinf\_vt.dats for arbitrary-precision integer operations using GMP.

samples/ATS · high confidence

New sample files have been added to the samples/Alloy directory, providing formal models for three distinct systems: a generic file system (file\_system.als), a mark-and-sweep garbage collector (marksweepgc.als), and object-oriented view mechanisms (views.als). These models allow users to explore and verify properties such as directory parentage, memory reachability, and view consistency using the Alloy Analyzer.

samples/Alloy · high confidence

Added sample files demonstrating the Antlers template syntax, including a blog index with pagination, a layout template, a sitemap generator, and a comprehensive 'kitchensink' file showcasing various template features like collections, partials, conditionals, and variable parsing.

samples/Antlers · high confidence

New sample files have been added to the samples/ApacheConf directory to help users configure the Apache HTTP server. These include a virtual host template (apache.vhost), a .htaccess file with security rules to block common attacks like SQL injection and bad user agents, and main server configuration files (apache2.conf and httpd.conf) for both Linux and macOS environments.

samples/ApacheConf · high confidence

A new sample file has been added to the repository containing the source code for the 'Burn, Baby, Burn' Master Ignition Routine from the Apollo Guidance Computer (Luminary 1A build 099). This file provides the historical AGC assembly code for the Lunar Module's ignition sequence, including associated tables and logic for programs P12, P40, P42, and P63.

samples/Apollo Guidance Computer · high confidence

Added two new AspectJ sample files to the project: CacheAspect, which implements a simple cache using a WeakHashMap triggered by the @Cachable annotation, and OptimizeRecursionCache, an abstract aspect designed to optimize recursive functions by caching results at the top level of recursion.

samples/AspectJ · high confidence

A new Avro IDL file (user.avdl) has been added to the samples directory, defining a protocol for user-related operations. This sample includes records for user summaries, settings, and proofs, along with methods for loading user data, managing public keys, editing profiles, and handling passphrase states.

samples/Avro IDL · high confidence

A new sample file (samples/Awk/test.awk) has been added to demonstrate an Awk script that parses system monitoring output (such as sysstat) and generates separate data files for CPU, network, disk, memory, and socket metrics.

samples/Awk · high confidence

A new sample file (guide.bbcode) has been added to the samples/BBCode directory, containing a changelog formatted in BBCode syntax. This file serves as a reference example for users on how to structure changelog entries using BBCode tags such as \[B\], \[SIZE\], \[LIST\], and \[URL\].

samples/BBCode · high confidence

A new sample configuration file for BIRD 2 has been added to the samples directory. This file demonstrates a comprehensive setup including static, BGP, and OSPF protocols, along with advanced features such as AS path filtering, community-based local preference adjustments, and functions for validating bogon prefixes and network lengths.

samples/BIRD2 · high confidence

New sample files have been added to the Berry language directory, providing a schema validator implementation (berry\_schema\_validator.be) and a driver for I2C LCD displays (lcd\_display.be). The schema validator offers JSON-schema-like validation capabilities, including checks for type, size, allowed values, and format patterns (such as time formats). The LCD display sample provides a direct port of the Arduino LiquidCrystal library, enabling users to control I2C-connected LCD screens with features like cursor control, backlight management, and text scrolling.

samples/Berry · high confidence

The samples/Bicep directory now includes three new example files: a template for provisioning an Azure Container Registry, a comprehensive template for deploying a virtual machine with two network interfaces, subnets, and a virtual network, and a parameter file demonstrating usage of a public AI module for OpenAI services.

samples/Bicep · high confidence

New sample files have been added to the BlitzBasic directory: HalfAndDouble.bb provides a library for converting between single-precision floats and half-precision (16-bit) integers, along with stubs for double-precision operations; LList.bb implements a double-linked list container class with methods for creation, iteration, insertion, removal, and conversion to/from memory banks; and PObj.bb demonstrates an object pooling pattern using Blitz3D handles to optimize repeated object creation and deletion.

samples/BlitzBasic · high confidence

New Blueprint language sample files have been added to the samples/Blueprint directory, providing declarative UI templates for a counter window and a sign-in page using GTK 4 and Adwaita 1.

samples/Blueprint · high confidence

The samples/Bluespec directory now includes a reference implementation of a traffic-light controller (TL.bsv) and its testbench (TbTL.bsv). The controller models a four-way intersection with pedestrian crossing, managing state transitions for North-South, East-West, and Pedestrian lanes based on car presence and pedestrian button presses. The testbench provides a simulation environment that instantiates the controller, monitors lamp state changes, and simulates vehicle and pedestrian activity to verify correct behavior.

samples/Bluespec · high confidence

The samples/CSS directory now includes both the standard and minified versions of Bootstrap v2.3.1. These files provide reference assets for testing CSS parsing and minification detection capabilities.

samples/CSS · high confidence

A new sample file (brainfuck.sl) has been added to the samples/Slash directory, providing a complete implementation of a Brainfuck interpreter including an AST, parser, and environment classes.

samples/Slash · high confidence

The samples/Brainfuck directory now includes several new example programs: a Hello World implementation, a more complex Hello World variant, a ROT13 cipher, a Fibonacci number calculator (up to 100), and a large-integer factorization script. These files provide ready-to-use reference implementations for users exploring the Brainfuck language.

samples/Befunge, samples/Brainfuck · high confidence

The samples/Browserslist directory now includes example configuration files (.browserslistrc and browserslist) that demonstrate various query syntaxes, including market share thresholds, specific browser versions, environment-specific blocks, and extended configurations.

samples/Browserslist · high confidence

A new example file (example.bru) has been added to the samples/Bru directory, demonstrating how to define HTTP requests, headers, and body content using the Bruno Markup Language syntax.

samples/Bru · high confidence

A new sample file (samples/C3/example.c3) has been added to showcase the C3 language's argument parsing capabilities. The example illustrates how to define and parse command-line options, including required arguments with valid value constraints, optional arguments, and boolean flags, while also providing a built-in test case for the parsing logic.

samples/C3 · high confidence

New sample files have been added to the samples/CLIPS directory to demonstrate the CLIPS rule-based programming language. The 'demo.clp' file implements an interactive animal classification expert system that asks users questions to identify animals based on biological traits. The 'sudoku.clp' file provides a knowledge base and rule set for solving Sudoku puzzles using various logical strategies and phases.

samples/CLIPS · high confidence

The samples/CMake directory now includes several new CMake configuration files demonstrating various build patterns. These include basic project setups (sample1-2.cmake), documentation generation targets using Sphinx (sample3.cmake), Vala compilation integration (sample4.cmake), a macro for checking stdcall function existence (sample5.cmake), a standard CMakeLists.txt for a simple executable (filenames/CMakeLists.txt), and a template for generating an uninstall script (uninstall.cmake.in).

samples/CMake · high confidence

New CUDA sample files have been added to the repository, providing reference implementations for GPU computing. The \samples/Cuda/vectorAdd.cu\ file demonstrates a basic vector addition kernel and host routine, while \samples/Cuda/scalarProd\_kernel.cuh\ introduces a kernel for computing scalar products with shared memory optimization and tree-like reduction. These samples serve as educational examples for CUDA development within the project.

samples/Cuda · high confidence

A new CartoCSS stylesheet (amenity-points.mss) has been added to the samples directory, providing styling rules for rendering various amenity and tourism points of interest on the map. The file defines specific point symbols, colors, and zoom-level thresholds for features such as alpine huts, shelters, ATMs, banks, bars, bicycle rentals, bus stops, cafes, camp sites, car sharing, cinemas, fire stations, fuel stations, hospitals, libraries, museums, and parking areas, allowing users to reference or integrate these visual styles into their map projects.

samples/CartoCSS · high confidence

The samples/iCalendar directory now includes a 2024.ics file containing Chinese public holidays and make-up workdays for 2024, along with a new todo-2.ical sample file demonstrating a completed to-do event.

samples/iCalendar · high confidence

New sample files have been added to the Clarion directory, including a basic 'Hello World' program, a 'HelloClass' member example, a custom CString class implementation with performance optimizations, and a ConsoleSupport module for Windows API console interaction.

samples/Clarion · high confidence

A new sample file providing Cloud Firestore security rules has been added to the samples directory. These rules enforce that users must be signed in to access data and restrict create, update, and delete operations to the document owner. The rules also validate the structure and field types for activities, skills, and their associations, ensuring data integrity before allowing modifications.

samples/Cloud Firestore Security Rules · high confidence

The samples/CodeQL directory now includes example CodeQL queries and model implementations for multiple languages. This adds a COBOL sample query that detects unconditional SELECT statements, a C\# sample query identifying redundant LINQ Select calls, and Python model samples defining class object internals, descriptor protocols, and property setters/deleters. Additionally, a generic QL sample demonstrates basic tree-sitter syntax structures.

samples/CodeQL · high confidence

A new Common Workflow Language (CWL) v1.0 sample file, \trunk-peak-score.cwl\, has been added to the samples directory. This workflow implements a command-line tool that processes ENCODE bed6+4 files to 'trunk' (cap) peak scores at a value of 1000 using \awk\. It accepts input peak files and a separator character, runs within the \dukegcb/workflow-utils\ Docker container, and outputs the processed scores to stdout.

samples/Common Workflow Language · high confidence

New sample files have been added to the Crystal directory to demonstrate language features. \const\_spec.cr\ provides tests for constant definition, nested constants, scope resolution, and expression evaluation. \declare\_var\_spec.cr\ covers type inference for variable declarations, including instance variables in generic classes and reopens. \transformer.cr\ implements an AST transformer module that recursively processes various Crystal AST node types (such as calls, conditionals, and definitions) to enable code transformation.

samples/Crystal · high confidence

A new sample file (utils.cy) has been added to the Cycript samples directory, providing a utility library for interacting with C functions within the Cycript environment. This script exposes helper functions to load, parse, and execute C declarations (such as those from standard libraries and Mach APIs) by leveraging dlsym and Cycript's @encode mechanism, allowing users to call native system functions directly from Cycript scripts.

samples/Cycript · high confidence

New Cypher script samples have been added to the \samples/Cypher\ directory to help users explore graph capabilities. These include \db\_export\_res.cypher\ for importing movie and person data, \graphgems.cypher\ and \graphgems.cyp\ containing ten advanced query examples (such as PageRank, betweenness centrality, and weighted shortest paths), and \load\_from\_json.cypher\ demonstrating how to load Stack Overflow data via APOC procedures.

samples/Cypher · high confidence

New D2 language sample files have been added to the samples/D2 directory. The anthias-diagram-overview.d2 file provides a visual representation of the Anthias system architecture, detailing components such as the Nginx server, viewer, WebSocket, Celery worker, Redis, and SQLite database, along with their data flows. The calc\_algo.d2 file documents the calculation algorithms, illustrating the data structures and processing flows for transaction queries, raw statistics, exchange rates, and exchange statistics.

samples/D2 · high confidence

A new example file (example.dm) has been added to the samples/DM directory, demonstrating core DM language features including pre-processor directives, variable declarations, class inheritance, proc definitions, and bitflag operations for users learning the syntax.

samples/DM · high confidence

A sample DirectX 3D model file (cube.x) has been added to the samples directory. This file defines a simple cube mesh with vertex positions, normals, and UV texture coordinates, providing a basic asset for testing or demonstrating 3D rendering capabilities within the DirectX ecosystem.

samples/DirectX 3D File · high confidence

New sample files have been added to the E language directory, demonstrating core language features such as object inheritance (Extends.E), closures and functions (Functions.E), capability-based security guards (Guards.E), file I/O (IO.E), promise-based control flow (Promises.E), and concurrent atomic updates with a Swing UI (atomic-updates.E). These samples are sourced from the E wiki and Rosetta Code to illustrate idiomatic E programming patterns.

samples/E · high confidence

Added four new EBNF grammar files (grammar.ebnf, material.ebnf, object.ebnf, types.ebnf) to the samples/EBNF directory. These files provide Extended Backus-Naur Form definitions for parsing statements, expressions, and functions, as well as specific grammars for 3D object materials, vertex/triangle data structures, and numeric types.

samples/EBNF · high confidence

A new sample file (samples/ECL/sample.ecl) has been added to demonstrate sliding join functionality in ECL. The sample defines record structures and datasets, then shows how to perform standard joins on computed values as well as several examples of sliding join syntax using age ranges and string comparisons.

samples/ECL · high confidence

The samples/EJS directory now includes template files using various extensions (.ejs, .jst, .ect, .ejs.t) to demonstrate EJS support. These samples provide UI layouts for an admin index page, a dashboard with role-based views, an email template editor, module configuration generation, and a practice piece management page.

samples/EJS · high confidence

A new sample project demonstrating how to build and package a Java application using Earthly has been added to the samples directory. The provided Earthfile defines targets to install Gradle, build the project, and package the resulting binaries and libraries into a Docker image.

samples/Earthly · high confidence

A new .cproject file has been added to the samples/XML/filenames directory, providing an Eclipse CDT project configuration for the 'Graph抽象資料結構' (Graph Abstract Data Structure) executable. This configuration sets up both Debug and Release build targets using the Linux GCC toolchain, enabling developers to import and build this sample directly within the Eclipse IDE.

samples/XML/filenames · high confidence

A new sample file (momentComponent.em) was added to the samples/EmberScript directory, demonstrating an Ember.View that renders a relative time string (e.g., '2 hours ago') using the moment.js library. The component updates its display every second via a scheduled tick and properly cleans up the timer when the element is destroyed. A Handlebars helper named 'fromNow' is also registered to allow easy usage of this view in templates.

samples/EmberScript · high confidence

New sample smart contracts implementing the FA1.2 (TZIP-7) token standard have been added for the CameLIGO, LigoLANG, and ReasonLIGO languages. These samples provide reference implementations for core token operations including transfers, approvals, and balance queries, with the LigoLANG and ReasonLIGO versions also including additional features such as minting, burning, and pausing capabilities.

samples/CameLIGO, samples/LigoLANG, samples/ReasonLIGO · high confidence

Added four new sample files in the samples/FLUX directory demonstrating the FLUX language syntax and concurrency patterns: gameserver.fx (a game server with message parsing and client management), imageserver.fx (an image serving pipeline with caching and compression), mbittorrent.fx (a BitTorrent client implementation with tracker and peer communication), and test.fx (a simplified test case for the image server logic). These samples illustrate source nodes, data flow definitions, type-based dispatch, and atomicity constraints.

samples/Clean, samples/FLUX · high confidence

The samples/Cadence directory now includes a complete set of example Cadence code for the Flow blockchain, featuring the FlowToken contract (implementing fungible token minting, burning, and transfers), the FlowFees contract (handling transaction fee deduction and parameter management), and utility scripts for setting up accounts, minting tokens, and reading balances.

samples/Cadence · high confidence

New FreeMarker template files have been added to the samples/FreeMarker directory to demonstrate usage, including a layout template (layout.ftl), a header component (header.ftlh), a card block component (blocks-card.ftlh), and an example page (example.ftl). These samples illustrate how to structure pages, handle localization, and render dynamic content using the FreeMarker engine.

samples/FreeMarker · high confidence

A new sample file (transport.gms) has been added to the GAMS samples directory, providing a basic transportation problem model that demonstrates least-cost shipping schedules between plants and markets.

samples/GAMS · high confidence

The \samples/Game Maker Language\ directory now contains a collection of GML source files, replacing previous GPL-licensed content. This addition includes the JSOnion JSON library (\jsonion.gml\, \jsonion\_test.gml\), Spelunky Community Update Project scripts for character movement and level generation (\characterDrawEvent.gml\, \characterStepEvent.gml\, \scrInitLevel.gml\), and Piwik analytics integration scripts (\\_piwikCacheRequest.gml\, \\_piwikSendBasicReq.gml\, \\_piwikSendReq.gml\).

samples/Game Maker Language · high confidence

A new NetLogo sample model implementing Conway's Game of Life has been added to the samples directory. This model allows users to simulate cellular automata with features for setting up blank or random initial states, running the simulation step-by-step, and interactively drawing or erasing cells using the mouse.

samples/NetLogo · high confidence

A new Gemini capsule file (instructions.gmi) has been added to the samples/Gemini directory, providing the FAQ and user guide for the 'Astrobotany' game. This content details account creation via self-signed certificates, gardening mechanics, plant growth stages, and generation scoring, serving as the static documentation for this sample application.

samples/Gemini · high confidence

A new \.git-blame-ignore-revs\ file has been added to the \samples/Git Revision List/filenames\ directory. This file configures Git to ignore specific commits (related to Prettier updates) when running \git blame\, helping to keep code history cleaner by excluding formatting-only changes. This requires Git version 2.23 or later.

samples/Git Revision List · high confidence

This change introduces a new sample directory for the Grace programming language. It includes a reference implementation of the Ackermann function and a complete GTK-based IDE (\grace\_IDE.grace\) featuring a multi-file editor with syntax highlighting, auto-completion, and a console for viewing execution output and errors.

samples/Grace · high confidence

The samples/Batchfile directory now includes the standard Windows batch scripts for the Gradle wrapper (gradlew.bat) and the Maven wrapper (mvnw.cmd). These additions allow users to build the project using the specific versions of Gradle and Maven bundled with the repository, ensuring consistent builds across different environments without requiring pre-installed build tools.

samples/Batchfile · high confidence

The samples/HLSL directory now includes new shader source files, specifically accelerated\_surface\_win.hlsl, bloom.cginc, corridor.fx, jellyfish.fx, and noise.fx. These additions provide users with reference implementations for various graphics techniques, including basic surface rendering, post-processing effects like bloom, and complex shading models such as reflection and refraction.

samples/HLSL · high confidence

The samples/Hack directory now includes a collection of Hack language source files (using .hh and .hhi extensions) and a .hack entry point, providing sample code for the Hack language. These files include type stubs for HHVM built-in classes like Map, controller and recipe base classes for the Hack Cookbook demo application, and utility functions for error handling and type assertions, enabling detection and syntax highlighting of Hack code in these formats.

samples/Hack · high confidence

New sample files for Handlebars templates have been added to the samples directory, including basic.handlebars and each.hbs, demonstrating standard template structures and iteration capabilities.

samples/Handlebars · high confidence

New Haskell source files have been added to the samples directory, providing reference implementations for users. These include a basic 'Hello World' script, a comprehensive library for colourising Haskell code (HsColour) supporting multiple output formats like ANSI, HTML, and LaTeX, a Sudoku solver with printing utilities, and a recursive maze-solving script that reads from standard input.

samples/Haskell · high confidence

The samples/Graphviz (DOT) directory now includes two new DOT files, 'annoying.DOT' and 'sample.dot', which provide example visualizations of Huffman trees generated from specific text phrases.

samples/Graphviz (DOT) · high confidence

A new Idris sample file (samples/Idris/Chars.idr) has been added to the repository, providing a module for character classification and transformation. This includes functions to check if a character is uppercase, lowercase, alphabetic, numeric, alphanumeric, or a specific whitespace character, as well as utilities to convert characters to upper or lower case and identify hexadecimal digits.

samples/Idris · high confidence

New pattern language definition files have been added to the samples directory, enabling users to parse and visualize JPEG images and SQLite 3 database files within ImHex. The JPEG sample defines structures for markers, segments, and pixel data, while the SQLite sample parses the database header, page types, and version information.

samples/ImHex Pattern Language · high confidence

The samples/Inform 7 directory now includes two new example files: 'Trivial Extension.i7x' and 'story.ni'. These samples demonstrate Inform 7 interactive fiction design, specifically highlighting the ability to embed Inform 6 code within Inform 7 extensions and stories, as well as proper handling of documentation sections and complex narrative logic.

samples/Inform 7 · high confidence

The samples/Ink directory now includes several new .ink files that serve as examples for complex storytelling techniques. These include murder\_scene.ink, a crime investigation example using lists and state tracking; print\_number.ink, a utility for converting integers to text; seen\_this\_scene.ink and thread\_in\_tunnel.ink, which provide helper functions for scene tracking and flow control; and string\_to\_list.ink, which demonstrates binding external C\# functions to handle list conversions from strings.

samples/Ink · high confidence

The repository now includes sample files for creating Windows installers using Inno Setup. This adds a default English language message file (Default.isl) containing standard setup wizard text, and an example installation script (expat.iss) for the Expat XML Parser, demonstrating how to package binaries, documentation, and source code into an installer.

samples/Inno Setup · high confidence

Added sample files for the Interactive Data Language (IDL), including a spectrum management class from the AmesPAHdbIDLSuite, utility functions for mathematical operations (inverse hyperbolic cosine, greatest common divisor, truncation), and a module definition file for analysis tools.

samples/IDL · high confidence

A new sample file (HelloWorld.thy) has been added to the Isabelle samples directory, demonstrating basic theory structure, lemma definitions, and proof techniques.

samples/Isabelle · high confidence

A MANIFEST.MF file has been added to the JAR Manifest samples directory, containing SHA digest entries for various cryptographic test and utility classes (such as CheckCerts, JarVerify, and PKCS7Test variants). This provides a reference for how JAR signatures and integrity verification are structured in sample code.

samples/JAR Manifest · high confidence

New Job Control Language (JCL) samples have been added to the repository to demonstrate common mainframe tasks. These include IEBCOPY for copying dataset members, IEFBR14 for creating and cataloging datasets, and IKJEFT01 for executing TSO/E commands such as listing users.

samples/JCL · high confidence

The samples/JFlex directory now includes two new JFlex specification files: LexScan.flex, which provides the core lexer scanner implementation for JFlex itself (version 1.7.0-SNAPSHOT), and java.jflex, which defines a lexer specification for recognizing Java 1.2 language syntax. These files serve as reference grammars and sample implementations for users working with JFlex-based lexical analysis.

samples/JFlex · high confidence

A new sample file (samples/JSONLD/sample.jsonld) has been added to demonstrate JSON-LD features, including context definitions, relative identifiers, and nested context resets.

samples/JSONLD · high confidence

New sample files have been added to the samples/Jasmin directory to demonstrate Jasmin assembly language patterns. These include if1.j, if2.j, if3.j, and if4.j, which illustrate various conditional branching structures (if/else logic and comparisons), as well as op1.j, op2.j, op3.j, and op4.j, which demonstrate arithmetic operations (add, subtract, multiply, divide, remainder), bitwise operations (AND, OR), and comparison-to-boolean conversions.

samples/Jasmin · high confidence

A new sample file (create.js.erb) has been added to the JavaScript+ERB samples directory. This file demonstrates how to render a model partial using ERB and append the resulting HTML to a DOM element with the ID 'models' via jQuery.

samples/JavaScript+ERB · high confidence

A new Jsonnet sample file has been added to the samples directory, demonstrating a workflow that performs an intersection of two sorted files using shell commands. This sample illustrates how to define reusable job templates and chain dependencies within a Jsonnet-based workflow definition.

samples/Jsonnet · high confidence

New sample files have been added to the Julia samples directory to demonstrate correct interpreter analysis. The 'julia' script provides a utility for printing full paths with clipboard support, while 'stockcorr.jl' implements a financial simulation using Geometric Brownian Motion to model correlated stock assets.

samples/Julia · high confidence

A new KRL (Knowledge Representation Language) sample file has been added to the samples directory, demonstrating a basic rule that triggers on a web pageview event and sends a notification.

samples/KRL · high confidence

A new sample board file (tc14badge.brd) has been added to the samples/KiCad Legacy Layout directory. This file represents a PCB design created with the legacy KiCad PCBNEW format (Version 1, dated 2012), providing users with a reference example for older KiCad board data structures.

samples/KiCad Legacy Layout · high confidence

A new sample file (demo.kit) has been added to the Kit samples directory, demonstrating the Kit language syntax with a page title and an included content block.

samples/Kit · high confidence

A new sample LESS stylesheet (screen.less) has been added to the samples/Less directory, demonstrating variable usage and color manipulation functions.

samples/Less · high confidence

A new LOLCODE sample file (LOLTracer.lol) has been added to the samples directory, providing a reference implementation of a tracer written in the LOLCODE language.

samples/LOLCODE · high confidence

New sample files (hello.blade and hello.blade.php) were added to the samples/Blade directory, demonstrating a Laravel Blade layout that utilizes directives such as @yield, @stack, @include, and @foreach to render dynamic content and partials.

samples/Blade · high confidence

New Lark grammar files have been added to the samples directory to support parsing Ancient Text Format (ATF) data and to demonstrate the core Lark syntax. The ebl\_atf.lark file defines the structure for Eblaite ATF lines, including imports for text, dollar, and at-line variants, while ebl\_atf\_common.lark provides shared definitions for objects, surfaces, and seals. Additionally, lark.lark contains the complete grammar specification for the Lark language itself, defining rules for tokens, imports, and expressions.

samples/Lark · high confidence

Added sample Latte template files (layout.latte, template.latte) in the samples/Latte directory that define the structure and content for a translation report page, including layout scaffolding, author display, revision diffing, and editor approval controls.

samples/Latte · high confidence

A new example .desktop file has been added to the samples directory, providing a reference implementation for integrating the application with the Linux desktop environment. This file defines the application as 'Foo Viewer', specifies its executable and icon, registers support for 'image/x-foo' MIME types, and configures custom context menu actions for browsing galleries and creating new items.

samples/desktop · high confidence

New sample files for the Liquid theme have been added to the repository, providing a reference implementation for Shopify storefronts. The \layout.liquid\ file defines the main HTML structure, including header, footer, navigation, and a mini-cart display, while \template.liquid\ demonstrates a product page layout with variant selection, pricing, and add-to-cart functionality.

samples/Liquid · high confidence

Added new Luau sample files providing utility modules for enums (EnumList), optional values (Option), unique identifiers (Symbol), hierarchical instance traversal (Tree), and data serialization (Ser). These samples demonstrate idiomatic Luau patterns including strict typing, read-only metatables, and safe instance path resolution.

samples/Luau · high confidence

The samples/M4Sugar directory now includes three new Autoconf macro samples: ax\_ruby\_devel.m4, which provides macros to detect Ruby development headers and libraries; filenames/configure.ac, a sample build configuration for a project named GARDEN that checks for the Allegro game library; and list.m4, which defines M4Sugar functions for managing lists (declare, add, get nth, pop front/back, contains). These files serve as examples of how to use M4Sugar for Ruby integration, complex build configurations, and data structure manipulation within Autoconf scripts.

samples/M4Sugar · high confidence

New sample files have been added to the samples/Marko directory, including counter.marko (a simple incrementing counter), hello.marko (displaying a greeting and a list of colors), and rgb-sliders.marko (an interactive RGB color picker using sliders). These samples demonstrate basic Marko component patterns such as state management, conditional rendering, loops, and event handling.

samples/Marko, samples/Vue · high confidence

A new sample view file (view.mask) has been added to the Mask samples directory, demonstrating the framework's template syntax including HTML element structure, variable interpolation, conditional rendering, list iteration, component usage with data binding, and animation definitions.

samples/Mask · high confidence

The repository now includes a new 'samples/Max' folder containing three files for a 'Hello' example: the patch definition (Hello.maxpat), its help file (Hello.maxhelp), and the compiled binary (Hello.mxt). These files provide a working example of a Max/MSP patch that toggles between 'Hello World !' and 'Goodbye World !' messages using a metro and counter object.

samples/Max · high confidence

Added sample files for the Meson build system, including a \meson.build\ script demonstrating project configuration, arguments, imports, loops, string literals, variables, and conditional logic, along with a \meson\_options.txt\ file defining a boolean option.

samples/D, samples/Meson, samples/Red · high confidence

The sample application now includes a new Metal shader file (ITMVisualisationEngine.metal) that implements GPU-accelerated kernels for visualizing the 3D scene. This addition enables hardware-accelerated raycasting against voxel data, rendering of ICP maps and forward projections, and forward projection of points, providing a Metal-based alternative for real-time 3D visualization within the sample.

samples/Metal · high confidence

A new sample file (showcase.mcfunction) has been added to the samples/mcfunction directory, demonstrating various Minecraft function syntax features such as raycasting logic, execute commands, scoreboard operations, data manipulation, and tellraw formatting.

samples/mcfunction · high confidence

Added new sample files for the Monkey2 language variant, including examples of basic syntax, graphics rendering, GUI construction, and sorting with generics.

samples/Monkey · high confidence

Added sample files (hello.moo, toy.moo) and the moocode\_toolkit.moo to the samples/Moocode directory, providing a basic implementation and examples for the Moocode experimental language package.

samples/Moocode · high confidence

New sample code has been added to the repository to demonstrate Motoko development. This includes a complete ERC20 token actor implementation in \samples/Motoko/erc20.mo\, featuring standard token functionality such as transfers, approvals, and balance queries, along with stable state management for upgrades. Additionally, a generic FIFO queue module (\samples/Motoko/queue.mo\) is provided to illustrate basic data structure patterns in Motoko.

samples/Motoko · high confidence

The samples/Muse directory now includes manual.muse and usage.muse, providing documentation for the Muse markup syntax and usage examples for Monikop and Pokinom tools.

samples/Muse · high confidence

New Mustache template files have been added to the samples directory, providing example templates for generating CSV rows, deleting users, displaying pupil information blocks, and showing all users.

samples/Mustache · high confidence

The samples/NCL directory now includes new NCL (NCAR Command Language) scripts demonstrating advanced data analysis and visualization techniques. PrnOscPat\_driver.ncl provides a function to compute Principal Oscillation Patterns (POPs) from EOF analysis, handling version-specific covariance matrix calculations. Several scripts (WRF\_static\_2.ncl, WRF\_track\_1.ncl) illustrate plotting WRF model outputs, including static land-use/soil maps and hurricane track visualizations. Additional samples cover COSMO model data (cosmolib\_1.ncl), CRU climate data climatology (cru\_8.ncl), HDF4 SEVIRI water vapor data (hdf4sds\_7.ncl), shapefile-based land/ocean masking (mask\_12.ncl), NAVO MCSST sea surface temperatures (mcsst\_1.ncl), JPEG image recreation as maps (topo\_9.ncl), pollutant trajectory plotting (traj\_3.ncl), T-S diagrams (tsdiagram\_1.ncl), and custom topographic maps (unique\_9.ncl).

samples/NCL · high confidence

New sample files in the \samples/NL\ directory, including \assign0.nl\ and \balassign0.nl\, provide examples of optimization problems in the NL file format. These files allow users to test solvers or tools that support this specific input format.

samples/NL · high confidence

A new sample file (\nearley-language-bootstrapped.ne\) has been added to the \samples/Nearley\ directory, providing the grammar definition for the Nearley language itself. This allows users to reference or utilize the specific syntax rules for parsing Nearley grammar files within the sample context.

samples/Nearley · high confidence

New sample files have been added to the samples/NetLinx directory to demonstrate NetLinx language syntax and usage. The projector.axi file provides a mock projector implementation showing device definitions, constants, structs, and button-event handling for input switching. The volume-array.axs file demonstrates volume control logic using the amx-lib-volume library, including array initialization and increment/decrement event handling for multiple audio inputs.

samples/NetLinx · high confidence

New sample files (sample.axi.erb and sample.axs.erb) have been added to the samples/NetLinx+ERB directory. These files provide a template for testing syntax highlighting in NetLinx+ERB projects, including examples of constant definitions and event handling logic.

samples/LSL, samples/NetLinx+ERB · high confidence

A new \\_redirects\ file has been added to the \samples/Redirect Rules/filenames\ directory, providing a reference configuration for Netlify. This sample demonstrates how to handle specific routing scenarios, including shadowing main pages to the index, processing search queries with query parameters, defining a custom 404 page, and splitting US English content using language headers.

samples/Redirect Rules · high confidence

The \samples/Nit\ directory now includes a collection of example programs demonstrating the Nit programming language. These samples cover a range of topics including GTK-based GUIs (calculator), C interop and callbacks (callback\_monkey, callback\_chimpanze), data structures (circular\_list, int\_stack), system interactions (curl\_http, curl\_mail, drop\_privileges), and basic language features (fibonacci, hello\_world, extern\_methods).

(repo-wide) · high confidence

A new Nix derivation has been added for Nginx version 1.4.4, enabling users to build and install the web server using the Nix package manager. The package includes support for SSL, SPDY, XSLT, sub-filtering, WebDAV, gzip static content, secure links, and IPv6. It also allows for optional integration of third-party modules, including the RTMP module, the WebDAV extension module, the syslog patch, and the headers-more module, depending on configuration flags.

samples/Nix · high confidence

New sample files have been added to the Nu language directory, including a Cocoa-based RandomApp demonstrating menu generation and application delegation, and a basic 'Hello' script entry point.

samples/Nu · high confidence

New sample files have been added to the OMNeT++ MSG and NED directories to provide reference implementations for specific network protocols and topologies. The MSG samples define packet structures and state variables for gPTP (GptpPacket.msg), TCP connection management (TcpConnection.msg, TcpConnectionState.msg), including FSM states and TCP options like SACK and Window Scale. The NED samples introduce network architecture components, including a base module for Time-Sensitive Networking (TsnNetworkBase.ned) with configurators for gate scheduling and stream redundancy, an IEEE 802.11 wireless interface module (Ieee80211Interface.ned) supporting various operational modes and radio models, and a generic wireless interface contract (IWirelessInterface.ned).

samples/OMNeT++ MSG, samples/OMNeT++ NED · high confidence

New sample applications have been added to the samples/Objective-J directory, demonstrating various UI patterns and capabilities of the Objective-J framework. These include a Flickr photo browser (AppController.j) that fetches and displays images using CPJSONPConnection, a 'Lights Off' puzzle game (LightsOff.j) featuring custom views and window management, and an iTunes-style layout demo (iTunesLayout.j) illustrating master/detail/auxiliary view arrangements with autoresizing masks.

samples/Genero 4gl, samples/Genero per, samples/LoomScript, samples/Objective-J · high confidence

New MMS/MMK build description files have been added to the samples/Module Management System directory to enable building legacy simulators and utilities on OpenVMS. The changes include \descrip.mms\ and \simh\_descrip.mms\ for compiling the SIMH package (supporting DEC C on Alpha, IA64, and VAX), \openvms.mmk\ for building Ghostscript with optional JPEG, PNG, and zlib libraries, \spline\_descrip.mms\ for a LISP interpreter, and \xv\_makefile.mms\ for the XV image viewer with JPEG and TIFF support.

samples/Module Management System · high confidence

A new sample project demonstrating loop constructs in the Oxygene language has been added to the samples directory. The project includes a main program file and associated properties, configured to build as an executable using the RemObjects Oxygene MSBuild targets.

samples/Oxygene · high confidence

A new example file for the Oz programming language has been added to the samples directory, demonstrating basic functional programming concepts such as summing squares, checking for prime numbers, and reversing a list.

samples/Oz, samples/XC · high confidence

New P4 sample programs have been added to the samples/P4 directory to demonstrate Layer-2 processing and traffic mirroring capabilities. The l2.p4 sample implements L2 forwarding logic, including spanning tree processing, source and destination MAC address lookups, and MAC learning notifications. The mirror\_acl.p4 sample provides a program for mirroring traffic based on ACL rules matching IP and MAC fields.

samples/P4 · high confidence

The samples/PHP/filenames directory now includes a .php script defining site navigation links (Blog, Photos, About me, Contact) and configuration files (.php\_cs and .php\_cs.dist) for PHP CS Fixer, enabling consistent code style enforcement for this sample.

samples/PHP/filenames · high confidence

The samples/PLpgSQL directory now includes several new SQL files that serve as reference implementations and test cases for PL/pgSQL. These additions cover the pg\_cron extension setup (pg\_cron.sql), various plpgsql\_lint test scenarios across PostgreSQL versions 8.4 through 9.3 (plpgsql\_lint-8.4.sql through plpgsql\_lint-9.3.sql), a sample procedure for handling location and observation data (procedures.sql), and a set of user account management functions from VirtualBox (useraccount.pgsql). These files provide concrete examples of PL/pgSQL syntax, including DO blocks, function definitions, exception handling, and diagnostic usage.

samples/PLpgSQL · high confidence

Added a collection of POV-Ray Scene Description Language (SDL) sample files to the repository, including a main 'balcony' demonstration scene and its associated include files (such as building, chair, table, and water components), along with a gamma handling test scene.

samples/POV-Ray SDL · high confidence

The samples/Papyrus directory now includes three new Papyrus script files: CAMTEST\_OverShoulderME.psc, which demonstrates camera manipulation and player control disabling for an over-the-shoulder effect; vMFX\_FXPlugin.psc, a minimal quest script; and vSCM\_MetaQuestScript.psc, which provides a framework for mod initialization, version tracking, and upgrade handling for the Smarter Combat Music mod.

samples/Papyrus · high confidence

The \samples/Pickle\ directory now includes two new \.pkl\ files: \data.pkl\, containing a simple Python object structure, and \neural-network-ce-l2reg-784-10-30.pkl\, containing a serialized NumPy array representing a neural network model. These files serve as test fixtures for validating Pickle data dump handling.

samples/Pickle · high confidence

A new example script (example.pig) has been added to the PigLatin samples directory, demonstrating a basic Pig script that loads data, projects a field, and dumps the result.

samples/PigLatin · high confidence

A new sample OWL file (sample.owl) has been added to the Web Ontology Language samples directory. This file contains the Pizza tutorial ontology (version 1.5), which defines classes for various pizzas and toppings, including restrictions on ingredients and country of origin, serving as a reference implementation for OWL constructs.

samples/Web Ontology Language · high confidence

A new sample file, \samples/PogoScript/squashy.pogo\, has been added to the repository. This PogoScript script demonstrates a utility for 'squashing' HTML pages by fetching external linked resources (such as stylesheets and scripts) and inlining their content directly into the original HTML document, effectively reducing the number of HTTP requests required to load the page.

samples/PogoScript · high confidence

New sample files defining authorization policies in the Polar language have been added to the samples/Polar directory. The gitcloud.polar file provides a comprehensive policy for a Git-like service, defining actors, resources (Organizations, Repositories, Issues), roles, and complex permission rules including inheritance and group-based access. The gitclub.polar file offers a simpler policy example for an organization and repository structure, demonstrating role assignments and basic permission checks.

samples/Polar · high confidence

The repository now includes sample ProGuard rule files in the \samples/Proguard\ directory to assist with code shrinking and obfuscation. These samples provide pre-configured rules for a wide range of popular Android libraries and frameworks, including Android Architecture Components, Dagger, Glide, Moshi, OkHttp, Retrofit, and various third-party SDKs like Facebook, Baidu, and JPush. Users can reference these files to ensure their dependencies are correctly preserved during the build process.

samples/Proguard · high confidence

Added a collection of sample Spin objects to the samples/Propeller Spin directory, including drivers for 4x4 keypads, PS/2 keyboards, LCDs, VGA/TV video output, graphics rendering, inductive sensors, and vocal tract synthesis.

samples/Propeller Spin · high confidence

A new sample file (addressbook.proto) has been added to the samples/Protocol Buffer directory, defining a tutorial package with Person and AddressBook message structures for use in Protocol Buffer examples.

samples/Protocol Buffer · high confidence

New PureBasic example files have been added to the samples directory. Example\_Sine.pb demonstrates real-time audio synthesis using the AudioOut library, allowing users to adjust frequency and amplitude via a graphical interface. Memory.pbi provides utility procedures for safe memory operations, including range-based copy, fill, and move functions that prevent buffer overflows.

samples/PureBasic · high confidence

The samples/R/filenames directory now includes an executable R script (expr-dist) that plots distributions of gene expression values before and after median normalization, along with R history files (.Rapp.history, .Rhistory) containing example code for PCA plotting and data visualization using ggplot2.

samples/R/filenames · high confidence

This change introduces a new RBS type definition file (\samples/RBS/cli.rbs\) that documents the interface of the \RBS::CLI\ class. It defines the structure for \LibraryOptions\, including attributes for core root, config path, libraries, directories, and repositories, as well as the \CLI\ class itself with its standard input/output streams and various command execution methods such as \run\, \run\_ast\, \run\_list\, and \run\_validate\. This provides static type information for the CLI component, aiding in development and tooling integration.

samples/RBS · high confidence

The samples directory now includes Rich Text Format (.rtf) versions of license documents, specifically \DesktopTemplateLicense.rtf\ and \LICENSE.rtf\ (containing the Apache License 2.0 text). These files provide formatted license templates for use within the sample project.

samples/Rich Text Format · high confidence

New sample files have been added to the Racket samples directory: a Racket script demonstrating the '99 Bottles of Beer' song logic and a Scribble manual document serving as an example for the Racket documentation tool. These additions provide users with concrete code examples for basic scripting and documentation generation within the Racket ecosystem.

samples/Racket · high confidence

The samples directory now includes Rascal language examples for the Rascal2muRascal compiler, featuring modules for syntax definitions, module information management, and translation logic, alongside a set of RouterOS scripts demonstrating configuration, VLAN setup, and automated backup/update workflows.

samples/Rascal · high confidence

The samples/HTML+Razor directory now includes two new sample files: Index.cshtml, demonstrating ASP.NET MVC Razor syntax with ViewBag usage, and Index.razor, a Blazor component implementing a people management interface with hire, fire, and edit capabilities. These files serve as examples of Razor syntax in both traditional MVC and Blazor contexts.

samples/HTML+Razor · high confidence

New sample files have been added to the \samples/Rebol\ directory, including \hello-world\ variants with extensions \.r2\, \.r3\, \.reb\, \.rebol\, and \.r\, as well as \GCP-datatypes.r\ and \booters.r\. These additions provide examples for different Rebol dialects and versions, and the \GCP-datatypes.r\ file specifically defines syntax highlighting rules for various Rebol data types (such as strings, numbers, dates, and logic) to improve code prettification in editors.

samples/Rebol · high confidence

A new Ren'Py demo script (example.rpy) has been added to the samples directory, providing a complete, public-domain visual novel example that demonstrates core engine features such as character definitions, scene transitions, dialogue, and interactive menus.

samples/Ren'Py · high confidence

New sample files have been added to demonstrate usage of the RenderScript and Filterscript APIs. The RenderScript samples include a 3x3 convolution filter implementation (convolve3x3.rs) and a scenegraph object definition header (scenegraph\_objects.rsh) defining structures for transforms, shaders, and rendering state. The Filterscript samples provide a color matrix transformation kernel (colormatrix.fs) and a basic kernel structure example (fs\_kernel.fs).

(repo-wide) · high confidence

Added a collection of Coq/Rocq proof scripts to the samples/Rocq Prover directory, including definitions for interactive computations (Computation.v), arithmetic expression optimization and evaluation (Imp.v), JavaScript interpreter correctness and extraction (JsCorrectness.v, JsInterpreterExtraction.v), number handling (JsNumber.v), pretty-printing of intermediate expressions (JsPrettyInterm.v), basic list operations (Lists.v, Poly.v), relational properties (Rel.v), small-step semantics (Smallstep.v), and temporal logic specifications (Spec.v).

(repo-wide) · high confidence

A new GEDCOM sample file, Royal92.ged, has been added to the samples/GEDCOM directory. This file contains genealogical data for the British Royal Family, sourced from a 1992 submission by Denis Reid, providing users with a realistic dataset for testing GEDCOM parsing and family tree visualization features.

samples/GEDCOM · high confidence

The samples/SQF directory now includes example files for the SQF scripting language. This adds fn\_remoteExecFnc.sqf, which provides a utility for executing functions on remote machines in multiplayer environments, and macros.hqf, which defines preprocessor macros for variable assignment, array conversion, and common hitpoint lists for units and vehicles.

samples/SQF · high confidence

New sample files have been added to the samples/STON directory to demonstrate STON serialization formats. These include examples for basic data structures (Array, Dictionary), complex objects (Rectangle, TestDomainObject), HTTP responses (ZNResponse), and metadata representations (methodProperties, properties).

samples/STON · high confidence

A new sample file (polinomios.sagews) has been added to the samples/Sage directory, providing Python/Sage functions for working with univariate polynomials. This includes utilities for generating lists of constant and non-constant polynomials, filtering for irreducible polynomials, converting between polynomial and vector representations, and completing the square for quadratic expressions.

samples/Sage · high confidence

A new sample file (.shellcheckrc) has been added to the samples directory to demonstrate how to configure ShellCheck using filename-based configuration. This sample sets the shell target to 'sh' and enables specific checks (avoid-nullary-conditions, deprecate-which, quote-safe-variables) while disabling others (SC2006, SC2021, SC2244) to address Solaris 8-9 compatibility and avoid suggestions for explicit '-n' operators in tests.

samples/ShellCheck Config · high confidence

The samples/Sieve directory now includes a collection of example Sieve scripts for mail filtering, such as archiving by date, flagging, header-based routing, spam detection, and vacation responses. These samples provide ready-to-use configurations for common mail management tasks.

samples/Sieve · high confidence

A new sample file (samples/Slim/sample.slim) has been added to demonstrate basic Slim syntax, including HTML structure, embedded JavaScript, conditional rendering, loops, and partial rendering.

samples/Nunjucks, samples/Scaml, samples/Slim · high confidence

A new Coccinelle SmPL script (atomic\_as\_refcounter.cocci) has been added to the samples directory to help identify code patterns where atomic\_t operations should be replaced with refcount\_t. This script detects specific atomic decrement and addition patterns that precede object freeing or destruction, providing reports to guide developers in migrating to safer reference counting APIs.

samples/SmPL · high confidence

A new Android.bp file has been added to the samples/Soong/filenames directory, providing a concrete example of how to build a Java plugin and library for detecting API usage in mainline modules. This sample includes a host Java library that utilizes Error Prone and Auto Service, along with a corresponding test suite and resource filegroup, demonstrating the build configuration for this specific tooling chain.

samples/Soong · high confidence

A new sample file (Squirrel.nut) has been added to the samples/Squirrel directory, demonstrating basic Squirrel scripting features such as tables, arrays, loops, class inheritance, and method calls.

samples/Squirrel · high confidence

Added three new Stan model files to the samples directory: a linear regression model for congressional voting data (congress.stan), a hierarchical logistic regression model for dog behavior trials (dogs.stan), and a hierarchical normal model for school effects (schools.stan).

samples/Stan · high confidence

Added new sample files for the Standard ML language, including \Foo.ML\, \Foo.sig\, \Foo.sml\, \RedBlackTree.fun\, and \main.fun\, which demonstrate lazy evaluation structures and red-black tree implementations. This change also updates the language definition to recognize \.ML\ and \.fun\ extensions for Standard ML files, ensuring these samples are correctly identified and highlighted.

samples/Standard ML · high confidence

New sample files have been added to the Stata directory to demonstrate usage and provide reference material. These include a regression example script (regress\_example.do), a basic program (hello.ado), Mata code for a hyperbolic tangent function (tanh.mata), and various help files (.hlp, .ihlp, .sthlp) covering topics like ODK metadata import and local macro limits.

samples/Stata · high confidence

A new demo file (demo.styl) has been added to the samples/Stylus directory, showcasing Stylus syntax features such as mixins, CSS vendor prefixes, variable usage, and the @extends directive for style inheritance.

samples/Stylus · high confidence

A new sample file (Adding.NCL.Language.S01E01.1080p.BluRay.x264.srt) has been added to the SubRip Text samples directory. This file serves as an example for the SubRip Text format, containing dialogue timestamps and text content.

samples/MDX, samples/SubRip Text · high confidence

New sample SQL files for T-SQL have been added to the samples/TSQL directory, including cursor.sql, logical.sql, storedprocedure.sql, and uniqueidentifier.sql. These files provide examples of T-SQL syntax such as cursor usage, logical functions (IIF, CHOOSE), stored procedure creation, and uniqueidentifier handling.

samples/TSQL · high confidence

New TLA+ model files have been added to the samples/TLA directory to formally specify system behavior. AsyncInterface.tla defines a basic asynchronous channel with send and receive operations, while fifo.tla builds upon this to model a bounded FIFO buffer that enforces a maximum queue length of 10 messages. These specifications include type invariants and theorems to verify that the buffer maintains data integrity during concurrent operations.

samples/TLA · high confidence

A new ABNF grammar file for TOML has been added to the samples directory, providing a formal definition of the TOML syntax according to RFC 4234. This resource allows users to reference or validate TOML structures against a standard grammar specification.

samples/ABNF · high confidence

A new sample file for the TXL language has been added at samples/TXL/Cal.txl. This file provides a simple numerical expression evaluator, defining the syntax for expressions, terms, and primary values, along with transformation rules to resolve addition, subtraction, multiplication, division, and parentheses.

samples/TXL · high confidence

Added three new TextGrid data files (part\_of\_speech.TextGrid, three\_tiers.TextGrid, and words.TextGrid) to the samples/TextGrid directory, providing example data for testing and demonstration purposes.

samples/TextGrid · high confidence

The samples/Type Language directory now includes builtin.tl and scheme.tl, providing sample definitions for the Type Language. These files define core types (such as Int, String, Vector), custom types (User, Group), arithmetic functions, and a comprehensive set of API functions and types for authentication, messaging, and media handling.

samples/Type Language · high confidence

New sample files have been added to the samples/UrWeb directory, including a signature file (parse.urs) defining a parser combinator library and an implementation file (iso8601.ur) that demonstrates parsing ISO 8601 datetime strings. These samples provide a reference implementation for building parsers in Ur/Web and a working example of parsing and displaying datetime values in a web interface.

samples/UrWeb · high confidence

The samples/DIGITAL Command Language directory now includes four new DCL scripts to assist with building and installing third-party libraries and tools on OpenVMS. fis\_gtm\_kitinstal.com provides the installation procedure for GT.M, handling configuration prompts and file placement. ghostpdl\_zlib\_make\_vms.com automates the compilation of the Zlib compression library, detecting the compiler and architecture. libxslt\_build.com builds the libxslt and libexslt libraries and the xsltproc utility, requiring a prior libxml installation. vmsbackup\_build.com compiles and links the VMSBackup utility using the DECC compiler.

samples/DIGITAL Command Language · high confidence

Added sample snippet files (\vim.snip\ and \vim.snippets\) for Vim users, providing templates for common constructs like conditionals, loops, functions, and plugin-specific hooks.

samples/Vim Snippet · high confidence

A new Visual Studio Solution file (Radiant.sln) has been added to the samples directory, enabling users to open and build the sample projects directly within Visual Studio. The solution groups the existing VB.NET and C\# sample projects (such as CSVAverage, CSVNormalization, and KillProcess) into a single workspace with Debug and Release configurations.

samples/Microsoft Visual Studio Solution · high confidence

A new sample file for the Volt language has been added to the samples directory. This sample demonstrates a test runner implementation that executes tests, tracks pass/fail/improvement/regression metrics, and outputs results to both the console and an XML file.

samples/HIP, samples/Processing, samples/Volt · high confidence

A new sample file, \wasi-io.wit\, has been added to the WebAssembly Interface Types samples directory. This file defines the WASI I/O API, including input and output stream types and operations such as read, write, skip, and splice, providing a reference implementation for stream-based I/O abstractions in WebAssembly components.

samples/WebAssembly Interface Type · high confidence

A new WGSL shader sample (\animate\_shader.wgsl\) has been added to the samples directory. This sample demonstrates an animated visual effect using the WGSL shading language, featuring time-based color mixing in the OKLAB perceptual color space and importing standard Bevy PBR mesh types and bindings.

samples/WGSL · high confidence

Added sample Wavefront OBJ and MTL files (dice, ripple, shapes, spline, and random) to the samples directories, providing reference assets for testing OBJ/MTL parsing and rendering capabilities.

samples/Wavefront Material, samples/Wavefront Object · high confidence

Added a new sample file (intro.wisp) that serves as an introductory guide to the Wisp language, a homoiconic JavaScript dialect with Clojure-like syntax. The file documents core data structures (nil, booleans, numbers, strings, characters, keywords, vectors, maps, lists), naming conventions, and special forms for arithmetic, comparison, logical operations, definitions, assignments, conditionals, and function handling.

samples/wisp · high confidence

New sample files for the Wollok educational programming language have been added to the repository. These include 'pepita.wlk', demonstrating object-oriented concepts like state management and method behavior with objects such as 'pepita', 'alpiste', and 'pepona', and 'piratas.wlk', illustrating class inheritance, constructors, and object-based logic through pirate-themed examples like 'Pirata', 'PirataAbstemio', and various mission objects.

samples/Wollok · high confidence

A new sample file has been added to the XCompose directory, providing a comprehensive set of custom X11 Compose key sequences. This file defines mappings for typographical symbols (such as various ellipses, dashes, and quotation marks), logical arrows, and Latin ligatures, allowing users to input these characters via multi-key combinations.

samples/XCompose · high confidence

A new sample XProc pipeline has been added to the samples directory, demonstrating a basic XML pipeline using the W3C XProc 1.0 specification. The sample defines a simple step that takes an inline XML document containing 'Hello world!' as input and passes it through an identity transformation to produce the output.

samples/XProc · high confidence

New sample files have been added to the samples/Xtend directory to demonstrate Xtend language features. BasicExpressions.xtend provides examples of literals, collections, control structures, and loops, while Movies.xtend illustrates data processing with a Movie class and operations on a CSV dataset.

samples/Xtend · high confidence

A new YANG module (sfc-lisp-impl.yang) has been added to the samples directory, defining the configuration schema for the sfc-lisp implementation. This module specifies the required service references for the binding-async-data-broker and binding-rpc-registry, enabling the system to wire these dependencies for the sfc-lisp component.

samples/YANG · high confidence

New YASnippet templates have been added to the samples directory to improve coding efficiency. The 'font-face' snippet (key: font) generates a complete CSS @font-face rule with support for multiple font formats (EOT, WOFF2, TTF, WOFF, SVG). The 'stdin' snippet (key: stdin) provides a JavaScript ES6 Promise-based pattern for reading data from standard input.

samples/YASnippet · high confidence

A new EasyBuild (.eb) file for bzip2 version 1.0.6 has been added to the samples directory, providing a reference configuration that uses the GCC 4.9.2 toolchain and ConfigureMake easyblock.

samples/Easybuild · high confidence

The navbar sample component is now fully registered for use in the XPages designer. A new navbar.xsp-config file defines the composite component metadata, making the navbar available in the designer palette, while a corresponding navbar.xsp.metadata file provides the necessary design-time attributes for the component.

samples/XPages · high confidence

A new sample crontab file has been added to the repository, providing a reference configuration for scheduling system tasks. It includes entries for running a whistleblower script on specific weekdays, an update script on Mondays, a daily cleanup job, and a receipts script on Mondays, all logging output to /opt/crontab.log.

samples/crontab · high confidence

A new sample file (samples/eC/Designer.ec) has been added, providing a concrete implementation of the Designer class for the eC environment. This sample demonstrates how to integrate a code editor and toolbox within a designer window, including handling file save operations, object management, and window lifecycle events.

samples/eC · high confidence

The samples/Lex directory now includes example source files for lexical analysis, specifically a Haskell-based Futhark lexer (Lexer.x) and a C-based Zend INI scanner (zend\_ini\_scanner.l). These additions provide reference implementations for parsing tokens in different languages and contexts.

samples/Lex · high confidence

The repository now includes sample linker scripts in the \samples/Linker Script\ directory, providing reference configurations for various architectures. These samples cover a compressed kernel layout for MIPS (\ld.script\), an ARM-specific script for injecting code (\inject.x\), a basic 32-bit x86 layout (\link.ld\), and a comprehensive modern x86 kernel script (\vmlinux.lds\) that supports both 32-bit and 64-bit modes with features like debug rodata protection and SMP per-CPU data handling.

samples/Linker Script · high confidence

Users can now identify and syntax-highlight mIRC Script files (\.mrc\) in the repository. This change adds the language definition and includes four sample scripts: \AutoHostmeBot.mrc\ for Twitch hosting automation, and three scripts for the game Torn City (\torncity-apiprofile.mrc\, \torncity-tcbot.mrc\, and \torncity-tsspy.mrc\) that provide profile management, universal assistance, and spy database tracking capabilities.

samples/mIRC Script · high confidence

The samples/HyPhy directory now includes several new example scripts for users to reference, including AAModelComparison.bf for amino acid model comparison, CodonModelCompare.bf for comparing 4x4 reversible codon models, MFPositiveSelection.bf for positive selection analysis, MatrixIndexing.bf for matrix operations, MolecularClock.bf for molecular clock testing, dNdSDistributionComparison.bf for dN/dS distribution comparisons, hyphy\_cmds.bf for detailed codon model optimization, and profile\_test.bf for performance profiling.

samples/HyPhy · high confidence

New sample files have been added to the samples/Puppet directory to demonstrate various Puppet language features and patterns. These include an Apache initialization manifest (apacheinit.pp) showing class parameters and resource management, an expiring host definition (expiringhost.pp) illustrating time-based resource expiration, a Hiera include example (hiera\_include.pp), a stages ordering example (stages-example.pp), and a pattern for handling unmanaged file changes with notify (unmanaged-notify-puppet25.pp).

samples/Puppet · high confidence

A sample APKBUILD file for the Alpine Abuild package (version 2.27.0) has been added to the samples directory. This file provides a reference implementation for building the abuild tool and its subpackages (cpan and gems resolver) on Alpine Linux, including build dependencies, source verification checksums, and installation steps.

samples/Alpine Abuild · high confidence

Two new sample scripts are now available in the KoLmafia ASH samples directory. The newDG.ash script automates the allocation of skills for the 'Dread Gnome' path, including handling muscle equalizer choices, collecting clan rumpus stuffies, managing Pantogram pants, and autoselling junk items. The tt\_kingliberated.ash script provides a post-core recovery workflow that configures HP/MP recovery settings, pulls items from ancestral storage, runs login and fortune scripts, and handles PvP preparation after the King is liberated.

samples/KoLmafia ASH · high confidence

New sample files have been added to the samples/AsciiDoc directory to demonstrate various AsciiDoc features. The new encoding.asciidoc file includes content with special characters and non-ASCII text (such as German and Japanese) to test encoding handling. The list.asc file provides an example of a document with a title and a simple unordered list. The sample.adoc file demonstrates a structured document with sections, subsections, a preamble, a note, and a list, serving as a comprehensive example of AsciiDoc syntax.

samples/AsciiDoc · high confidence

A new sample file named cars.csv has been added to the samples/CSV directory. This file contains a small dataset with columns for Year, Make, Model, and Length, providing example data for users to reference or test against.

samples/CSV · high confidence

New sample configuration files have been added to the repository to demonstrate specific Caddy features. The acmeserver.Caddyfile provides examples for setting up an internal ACME server with both standard and long-lived certificate authorities, while reverseproxy.caddyfile illustrates advanced reverse proxy behaviors, including conditional status code replacement and custom response handling based on request headers or upstream status codes.

samples/Caddyfile · high confidence

A new sample file (example.ch) has been added to the Charity samples directory, providing a basic example of a Charity data structure definition for the xBase .ch file format.

samples/Charity · high confidence

Two new sample DNS zone files have been added to the samples directory to provide reference configurations. The new 'sample.arpa' file defines an IPv6 reverse lookup zone (ip6.arpa) with a PTR record for a SIP endpoint, while 'sneaky.net.zone' provides a standard forward lookup zone example for a domain with A and NS records.

samples/DNS Zone · high confidence

A new sample file (samples/Isabelle ROOT/filenames/ROOT) has been added to demonstrate the syntax of Isabelle session ROOT files. This file contains examples of session definitions, including options, global theories, and file references, serving as a reference for users working with Isabelle project structures.

samples/Isabelle ROOT · high confidence

Added two new sample files in the samples/OverpassQL directory: a simple query demonstrating geocoding and highway filtering in Australia, and a complex query for extracting node and relation data with CSV output.

samples/OverpassQL · high confidence

Added several new sample files in the samples/Pod directory, including S15-unicode.pod (Pod 6 format), Cookbook.pod, PSGI.pod, Sample.pod, and contents.pod, providing examples of Pod syntax and documentation structures.

samples/Pod · high confidence

A new RAML 0.8 specification file has been added to the samples directory, defining a 'World Music API' with a v1 version. This sample demonstrates API structure including paged and secured traits, query parameter filtering by genre, and response schemas for JSON and XML formats for song resources.

samples/RAML · high confidence

Added three new sample files in the samples/SAS directory to demonstrate SAS syntax and usage: data.sas (showing basic DATA step operations), detect\_phi.sas (providing a macro for detecting Protected Health Information), and proc.sas (illustrating PROC steps for sampling, imputation, and logistic regression).

samples/SAS · high confidence

This change introduces new sample files for SELinux policy configuration, including Common Intermediate Language (CIL) templates for certificate files and the Guix daemon, as well as base policy definition files such as security classes, initial security identifiers, and filesystem contexts. These samples provide reference implementations for defining object types, access rules, and filesystem labeling conventions within the SELinux framework.

samples/CIL, samples/SELinux Policy · high confidence

New sample files have been added to the samples/SQLPL directory to demonstrate Oracle PL/SQL syntax support. These include check\_reorg.sql, comm\_amount.db2, drop\_table.db2, runstats.sql, sleep.sql, and trigger.sql, which showcase various procedural constructs such as stored procedures, functions, triggers, and control flow statements.

samples/SQLPL · high confidence

New sample Talon files have been added to the samples/Talon directory, providing voice-controlled commands for text editing. The find\_and\_replace.talon file introduces commands for searching, replacing, and navigating occurrences of text (including case, word, and regex matching), as well as quick actions to clear, comment, go to, paste, replace, or select previous and next occurrences. The line\_commands.talon file adds commands for moving to specific line numbers, commenting, clearing, copying, cutting, pasting, indenting, retabbing, swapping, cloning lines, and navigating by camel case boundaries.

samples/Talon · high confidence

The samples/Tree-sitter Query directory now includes example query files (such as highlights.scm, injections.scm, and tags.scm) that define syntax highlighting rules, code injection logic, and tag definitions for various languages including assembly, C/C++, Rust, and TLA+. These samples serve as reference implementations for how Tree-sitter queries can be structured to enhance code navigation and visual representation.

samples/Tree-sitter Query · high confidence

New sample schema files have been added to the samples/Vespa Schema Definition directory to demonstrate Vespa configuration patterns. The msmarco.sd file provides a schema for the MS MARCO dataset, including fields for text content and pre-computed vector embeddings (Word2Vec, GSE, BERT) with various rank profiles combining BM25 and vector similarity. The music.sd file defines a schema for a music catalog with specific indexing and filtering configurations for genre values. The ranking.sd file illustrates how to integrate an ONNX model for global-phase reranking and demonstrates function-based ranking expressions.

samples/Vespa Schema Definition · high confidence

A new sample file (sample.reg) has been added to the samples/Windows Registry Entries directory. This file serves as a reference for Windows Registry Editor syntax, illustrating various registry value types (such as strings, DWORDs, binary data, and multi-string values), key deletion, and the use of both long and short hive names (e.g., HKEY\_LOCAL\_MACHINE vs HKLM).

samples/Windows Registry Entries · high confidence

New sample files have been added to demonstrate usage of the Pug template engine and the Ragel state machine compiler. The Pug samples include a basic HTML structure in both the legacy .jade and current .pug formats, while the Ragel samples provide Ruby implementations for parsing ephemeris data, scanning for specific text blocks, and tokenizing input streams.

samples/Pug, samples/Ragel · high confidence

New sample configuration files have been added to the repository to help users configure common command-line tools. This includes a \.inputrc\ file for Readline with settings for symlink handling and text completion, a comprehensive \.wgetrc\ file for Wget covering global and local preferences such as proxy settings, recursion limits, and encoding, and a \.curlrc\ file for cURL with defaults for user-agent spoofing, timeout behavior, and progress feedback.

samples/Readline Config, samples/Wget Config, samples/cURL Config, samples/SSH Config · high confidence

The samples directory now includes two new container build files: a \debian-systemd.Containerfile\ that sets up a Debian Bullseye environment with systemd and bash-completion, and a \filenames/Dockerfile\ that demonstrates a legacy build process for Docker itself on Ubuntu 12.04 using Go 1.1.1. These samples provide reference configurations for running systemd-based containers and for building older versions of the Docker engine.

samples/Dockerfile · high confidence

New sample files have been added to the repository: a Survex survey data file (\samples/Survex data/data.svx\) containing cave survey measurements, and an mdsvex recipe guide (\samples/mdsvex/Stores.svx\) explaining Svelte store contracts and custom store implementations.

samples/Survex data, samples/mdsvex · high confidence

New sample files have been added to the \samples/SPARQL\ and \samples/Turtle\ directories to demonstrate usage of these formats. The SPARQL samples include \foaf.sparql\ for querying FOAF data and \string-matching.sparql\ for performing string matching against the Finto API. The Turtle samples provide \gnd-record.ttl\, a detailed RDF graph representing a GND authority record for Bertolt Brecht, and \rdf-syntax-grammar.ttl\, a small example referencing the RDF/XML Syntax Specification.

samples/SPARQL, samples/Turtle · high confidence

A new sample configuration file (sample.dircolors) has been added to the samples/dircolors directory, providing a reference for customizing file type colors in terminal emulators. This file defines color codes for various file types (such as directories, executables, and archives) and file extensions (including images, videos, and audio formats), allowing users to easily adapt terminal color schemes.

samples/Cabal Config, samples/Tor Config, samples/dircolors · high confidence

A sample email file (example.eml) has been added to the samples/E-mail directory, providing a MIME message example containing both HTML content and an embedded image.

samples/E-mail · high confidence

New sample files have been added to demonstrate the GN build system configuration and Python scripting. The GN samples include build configurations for V8 test isolation, Android and iOS build rules, compiler toolchains (GCC and Clang), ICU integration, and internal build rules. The Python samples provide examples of an additive wave animation, a Cinema 4D Python plugin, and other Python-based scripts.

samples/Python · high confidence

Added sample files for Graph Modeling Language (GML) and Yacc to the samples directory. The GML samples demonstrate graph structures with nodes, edges, and attributes, while the Yacc sample provides a calculator grammar definition.

samples/Graph Modeling Language · high confidence

New sample files have been added to the repository to support syntax highlighting for HiveQL and Kdb q. For HiveQL, this includes \mi.q\ and \query.hql\ demonstrating table creation, partitioning, and joins. For Kdb q, samples include \ml.q\ (implementing machine learning algorithms like k-means and ID3 decision trees) and \tq.q\ (handling trade and quote data).

samples/HiveQL · high confidence

New sample files have been added to the repository to support syntax highlighting for the KCL and KFramework languages. The KCL samples (complex.k, simple.k) demonstrate application models and Kubernetes manifest generation, while the KFramework samples (sample1.k, sample2.k) illustrate syntax definitions and configuration rules for the K framework.

samples/KCL, samples/KFramework · high confidence

The samples/Text directory now includes new sample files to support additional language and format detection. This includes Norwegian text samples with .nb and .no extensions (aptitude-defaults.nb, tutor.nb, tutor.no), NCL (NCAR Command Language) help documentation files (.ncl), and other standard text samples (foo.txt, mac.txt, messages.fr, readme.txt).

samples/Text · high confidence

New sample files have been added to the PostScript language directory to support syntax highlighting and detection. This includes a PostScript Font ASCII file (lambda.pfa), a standard PostScript script generating a Sierpinski triangle (sierpinski.ps), and an Encapsulated PostScript file containing the X Window System logo (xlogo.epsi).

samples/PostScript · high confidence

The samples/RMarkdown directory now includes example files for both Quarto (.qmd) and R Markdown (.rmd). The new .qmd sample demonstrates a Python-based matplotlib polar plot, while the .rmd sample provides a basic R Markdown template with R code chunks for plotting.

samples/RMarkdown · high confidence

The repository now includes sample files for Groovy Server Pages, Ioke, Kotlin, Logtalk, Nemerle, Opa, Parrot Assembly, Parrot Internal Representation, SCSS, Sass, Scilab, Tea, VHDL, XQuery, and XSLT. These additions expand the library of language samples available for testing and demonstration purposes.

(repo-wide) · high confidence

New sample files have been added to support recognition and syntax highlighting for additional Groovy file extensions, including .gvy, .grt, and .gtpl. A sample Jenkinsfile has also been included to demonstrate Groovy-based pipeline syntax, alongside basic script samples for .groovy and .gvy extensions.

samples/Groovy · high confidence

Added several sample public key files to the 'samples/Public Key' directory, including GPG keys (gpg\_key.asc, id\_dsa.asc, id\_rsa.asc, sunCert.asc) and SSH keys (id.pub, id\_rsa.pub, sshkey1.asc). These samples provide reference data for public key formats used in GPG and SSH contexts.

samples/Public Key · high confidence

A new sample file (samples/M/Comment.m) has been added to illustrate valid M language syntax for comments and tags. The routine shows that comments begin with a semicolon, allows various graphic characters within comments, and demonstrates different tag formats including alphabetic, numeric, and special character prefixes, as well as tags with formal parameter lists.

samples/M · high confidence

New sample files have been added to the samples/ShellSession directory to demonstrate shell session syntax. These include dollar.sh-session and simple.sh-session, which show basic command output, and gem-install.sh-session, which provides a longer example of a gem installation process including error handling and homebrew interactions.

samples/ShellSession · high confidence

Adds a collection of Swift code samples in the samples/Swift directory, covering basic syntax, control flow, functions, classes, inheritance, enums, protocols, and generics.

samples/Swift · high confidence

The C++ sample directory has been significantly expanded with new files covering a wider range of C++ features and use cases. New file extensions are now represented, including \.inc\ (inline code), \.inl\ (inline implementations), \.cppm\ (C++20 modules), \.ipp\ (inline templates), and \.re\ (re2c lexer definitions). The samples now include modern C++ constructs such as \constexpr\ variables, \\[\[nodiscard\]\]\ attributes, and C++20 module definitions (\export module\). Additionally, the collection now features code generated by external tools like Protocol Buffers and gRPC, as well as samples from various open-source projects (e.g., Boost.Asio, Swift, Haiku) to improve detection accuracy for these specific patterns.

samples/C++ · high confidence

The Erlang sample directory has been significantly expanded to cover more of the language ecosystem. New sample files include Erlang application resource files (\.app\ and \.app.src\), Elixir parser definitions (\.yrl\), and Lisp Flavoured Erlang (LFE) lexer definitions (\.xrl\). Additionally, several new executable and script samples have been added, such as \170-os-daemons.es\, \factorial\, \hello.escript\, \release\, and \single-context.es\, alongside utility modules like \record\_helper.erl\ and \record\_utils.erl\ for record manipulation.

samples/Erlang · high confidence

The samples/Forth directory now includes a broader range of Forth code samples, adding support for various file extensions (.fth, .fr, .frt, .4TH, .forth, .fs, .for, .F) and new content such as an x86 assembler (asm.fr), bitmap utilities (bitmap.frt), block I/O (block.fth), core and core-extension words (core.fth, core-ext.fth, etc.), enumeration helpers (enum.frt), macro tools (macros.frt), and debugging utilities (tools.fth). Additionally, a new sample for the Omgrofl language has been added in samples/Omgrofl/hello.omgrofl.

samples/Forth · high confidence

The samples directory now includes a broader range of GLSL and ShaderLab examples, supporting additional file extensions such as .gl2, .glslf, .rchit, .rmiss, .gs, .vsh, .fsh, .frg, .vrx, .comp, .tesc, and .tese. New samples demonstrate advanced rendering techniques including ray tracing (closesthit/miss shaders), tessellation (PN triangles), lens distortion, and various blending modes, while ShaderLab samples provide Unity-style post-processing effects like depth of field, fog, and an uber shader.

samples/GLSL · high confidence

The samples/Gerber Image directory has been populated with a diverse set of new Gerber and NC drill files, providing users with more examples for testing and validation. The additions include standard Gerber layers (copper, mask, silk, paste, edge cuts) from projects like 'FelinaePurr' and 'simonShield', as well as specialized formats such as .gml, .ncl, and .gko contour files.

samples/Gerber Image · high confidence

The JavaScript samples directory has been significantly expanded to include new representative files and support additional file extensions. New samples include \axios.es\ and \index.es\ (ECMAScript modules), \constant\_fold.mjs\ and \entry.mjs\ (ES modules), \chart\_composers.gs\ (Google Apps Script), \gen-js-linguist-thrift.js\ (Thrift-generated code), and \helloHanaEndpoint.xsjs\/\helloHanaMath.xsjslib\ (SAP HANA XS). Existing samples like \bootstrap-modal.js\, \ccalc-lex.js\, \ccalc-parse.js\, and \http.js\ provide broader coverage of legacy and generated JavaScript patterns.

samples/JavaScript · high confidence

The PHP samples directory now includes representative files from major frameworks and code-generation tools, providing better recognition for Symfony Console and BrowserKit components, CakePHP controllers and models, Drupal modules, Yii console bootstraps, and generated code from Protocol Buffers and Thrift. Additionally, new samples demonstrate PHP syntax highlighting via the .phps extension, FastCGI script handling with .fcgi files, and basic PHP scripts, ensuring more accurate detection across diverse PHP codebases.

samples/PHP · high confidence

The samples/Pascal directory has been significantly expanded with a variety of new source files, including configuration headers (.inc), unit files (.pp), and program files (.pascal). This update introduces samples for specific use cases such as a Bulls and Cows game, Windows directory handling, Lazarus COM object registration, and vector/matrix operator overloads. Additionally, the collection now supports the .pp and .inc extensions for Pascal files, broadening the range of code patterns available for reference.

samples/Pascal · high confidence

The Perl samples directory has been significantly expanded with new files covering multiple Perl dialects and use cases. New samples include Perl 6 (Raku) code in \use5.pl\ (demonstrating \use 5.20.0\ and experimental features), Perl 5 scripts like \fib.pl\ and \test-perl.pl\, and autosplit library files with the \.al\ extension (\fetch\_page.al\, \getchar.al\). The collection now also features real-world Perl modules and applications, including \Plack::Request\ and \Plack::Response\ (PSGI web interface), \App::Ack\ (file search tool), \Algorithm::Evolutionary::Fitness::Any\, \Color::Palette::Schema\, a CGI script (\example.cgi\), an exception handler (\exception\_handler.pl\), and a data plotting utility (\feedgnuplot\).

samples/Perl · high confidence

The Ruby filenames sample directory now includes configuration files for a broader range of Ruby development tools, providing users with reference examples for setup and automation. New additions include \.irbrc\ and \.pryrc\ for interactive shell configurations, \Dangerfile\ for CI/CD review automation, \Rakefile\ for task management, \Appraisals\ for multi-version gem testing, and \.simplecov\ for code coverage reporting. The update also adds samples for iOS/macOS development workflows with \Fastfile\, \Deliverfile\, and \Snapfile\ (part of the fastlane suite), macOS package management via \Brewfile\, deployment automation with \Capfile\, and static type checking with \Steepfile\.

samples/Ruby/filenames · high confidence

Added a collection of new SQL sample files in the samples/SQL directory to improve syntax highlighting and language detection for various SQL dialects and scenarios. The additions include Oracle PL/SQL procedures (AvailableInSearchSel.prc), PostgreSQL SQL-language function tests (create\_function\_sql.sql), Oracle DDL scripts (create\_stuff.sql, dual.sql, filial.tab), MySQL database dumps and schemas (db.sql, mysql-sakila-schema.sql, zipcodes.uk.mysql), SQLite schema adaptations (sqlite-sakila-schema.sql), Cassandra CQL definitions (videodb.ddl), and generic SQL utility scripts (drop\_stuff.sql, hostcache\_set\_state.inc, object-update.udf, suspendedtoday.viw).

samples/SQL · high confidence

The Scheme samples directory now includes additional example files using the .sld (R6RS library), .sls (R7RS library), and .sch extensions, alongside existing .sps and .scm files. New samples include a Scheme implementation of the classic Asteroids game, a library definition example, R7RS string port utilities, a lambda\* macro implementation, and the Sboyer logic programming benchmark, providing broader coverage of Scheme dialects and use cases.

samples/Scheme · high confidence

The Shell samples directory now includes a broader range of script files and configuration examples, enhancing syntax highlighting coverage for less common shell-related formats. New additions include package build scripts (\.pacscript\), shell themes (\.zsh-theme\), and job submission scripts for HPC environments (\.slurm\, \.sbatch\). The collection also adds samples for CGI scripts (\.cgi\, \.fcgi\), macOS shell scripts (\.command\), and various standard shell interpreters (\.bash\, \.sh\, \.zsh\). Additionally, specific tooling scripts for \rbenv\, \rvm\, and \sbt\ are now provided as samples.

samples/Shell · high confidence

The Shell language detection now recognizes a broader set of configuration and wrapper filenames, including \.bash\_aliases\, \.bash\_functions\, \.bash\_logout\, \.bash\_profile\, \.bashrc\, \.cshrc\, \.envrc\, \.flaskenv\, \.kshrc\, \.login\, \.profile\, \.tmux.conf\, \.xinitrc\, \.xsession\, \.zlogin\, \.zlogout\, \.zprofile\, \.zshenv\, \.zshrc\, \9fs\, \PKGBUILD\, \bash\_aliases\, \bash\_logout\, \bash\_profile\, \bashrc\, \cshrc\, \gradlew\, \kshrc\, \login\, \man\, \mvnw\, \profile\, \tmux.conf\, \xinitrc\, \xsession\, \zlogin\, \zlogout\, \zprofile\, \zshenv\, and \zshrc\. This ensures that these common shell scripts and configuration files are correctly identified as Shell code.

samples/Shell/filenames · high confidence

The samples/Starlark directory now includes a broader set of example files to demonstrate Starlark usage across different build systems and contexts. This adds support for the STAR language variant with .star file extensions (including schedule, pipeline, and symmetry operator samples), introduces Bazel-specific configuration files such as MODULE.bazel for bzlmod, WORKSPACE.bazel, and WORKSPACE.bzlmod, and provides concrete build rule examples like closure\_js\_binary.bzl for JavaScript compilation, Tiltfile for local development workflows, and various BUILD/BUCK files for Gerrit and Skia projects.

samples/Starlark · high confidence

The samples/TypeScript directory has been significantly expanded to demonstrate a wider range of TypeScript usage. New samples include a CLI wizard entry point (bin.ts) requiring Node.js 18.20.0+, a GraphQL cache implementation (cache.ts), and class inheritance patterns (classes.ts). The collection now supports modern TypeScript module extensions with new .mts (conditionParser.mts) and .cts (promisified\_cp.cts) files, as well as generated protocol buffer code (proto.ts). Additionally, runtime-specific samples have been added for Bun (demo.ts) and Deno (main.ts), showcasing platform-specific features like scheduled messaging and server initialization.

samples/TypeScript · high confidence

The Vim script samples directory now includes additional configuration files (.exrc, .gvimrc, .nvimrc, .vimrc, \_vimrc) and a comprehensive settings example (settings.vimrc) that demonstrates plugin management with Vundle and Pathogen, the Solarized colorscheme, and custom status-line functions. It also adds sample Vimball archives (textobj-rubyblock.vba, todo.vmb) containing plugins for Ruby block text objects and todo list management, along with the Solarized colorscheme source (solarized.vim).

samples/Vim script · high confidence

The samples/YAML directory now includes test fixtures and syntax definitions for a broader range of YAML-based formats, ensuring better recognition and parsing support for specific ecosystems. New additions include syntax highlighting definitions for Ansible (Ansible.YAML-tmLanguage), HexInspect (HexInspect.sublime-syntax), and R Console (source.r-console.syntax). The collection also adds sample files for MySQL database configurations (database.yml.mysql), Kubernetes CoreDNS manifests (coredns.yaml.sed), VCR cassettes (vcr\_cassette.yml), and LLVM MIR files (expected-floating-point-literal.mir), alongside a standard YAML spec example (229Q.yaml).

samples/YAML · high confidence

The samples/YAML/filenames directory now includes additional YAML-based configuration and lock files to demonstrate various syntaxes. New samples cover C/C++ tooling configurations (.clang-format, .clang-tidy, .clangd), JavaScript linting (.eslintrc), Ruby gem settings (.gemrc), semantic-release workflows (.releaserc), and software citation metadata (CITATION.cff). Additionally, lock files for Go dependency management (glide.lock) and the Pixi package manager (pixi.lock) have been added to the collection.

samples/YAML/filenames · high confidence

The Assembly samples directory has been significantly expanded with new files supporting multiple assembly dialects and architectures. New samples include FASM (FASM.asm), NASM (cpu\_feat.nas, fftfpu.nas, forth.nas), Intel 8051 (External Interrupt.a51), Motorola 68k (3D\_PRG.I, A8514.i), MSP430 (fp\_sqr32\_160\_comba.inc), and a custom 16-bit compiler (sectorc.s). Additionally, a new Nasal samples directory has been introduced with aircraft damage and avionics simulation scripts (damage.nas, kx165tso.nas).

samples/Assembly, samples/Just · high confidence

The samples/XML directory has been significantly expanded with new example files for a wide variety of XML-based formats, including JetBrains color scheme files (.icls), Qt translation files (.ts), Schematron validation files (.sch), Avalonia XAML (.axaml), Visual Studio templates (.vstemplate), Salesforce workflows (.workflow), MSBuild project files (.props, .sfproj, .jsproj), macOS interface builder files (.xib), JavaFX FXML (.fxml), GameMaker project files (.gmx), and policy files (.mdpolicy). This addition ensures that these specific XML dialects are now represented in the sample set for testing and demonstration purposes.

samples/XML · high confidence

The samples/INI directory now includes a broader set of example files to demonstrate syntax highlighting for various INI-style formats. This adds sample files for systemd unit types (service, socket, target, timer, mount, network, container), KiCad project files (.pro), MySQL view definitions (.frm), Java Properties files, Lektor project files (.lektorproject), and other configuration formats like .cnf, .dof, and .container. Additionally, the samples/KiCad Layout directory has been populated with footprint definition files (.kicad\_mod).

samples/INI · high confidence

The samples directory now includes a comprehensive collection of ignore list files for various tools and environments, such as \.eleventyignore\, \.eslint-ignore\, \.easignore\, \.vercelignore\, \.markdownlintignore\, \.dockerignore\, and \.vscodeignore\, alongside standard \.gitignore\ variants. Additionally, new Git configuration samples have been added, including \aliases.gitconfig\ with extensive command shortcuts, \.gitmodules\ for submodule management, and various filename-specific configs like \.gitconfig\ and \config.worktree\ to assist users in setting up their development environments.

samples/Ignore List · high confidence

Developers can now use GitHub Codespaces or local VS Code DevContainers to run the project. The environment is based on the Ruby 3.4 image, includes Docker-in-Docker (without Moby), and installs Go, Git LFS, and Rust. VS Code extensions for EditorConfig, YAML, and the Shopify Ruby LSP are pre-installed, and the container automatically runs the bootstrap script and fetches the linguist v2.0.0 branch on creation.

.devcontainer · high confidence

Added AGENTS.md to provide structured guidance for AI agents working with the Linguist repository, covering project overview, key files, development environment setup, and common tasks. Updated .gitignore to exclude additional build artifacts and local environment files. Introduced a Brewfile for managing macOS dependencies and a Dockerfile to containerize the build environment using Ruby 3.4 Alpine. Updated the README with comprehensive installation instructions, dependency requirements, and usage examples for both application and command-line modes.

(repo-wide) · high confidence

Two new command-line executables are added to the \bin\ directory: \git-linguist\ and \github-linguist\. The \git-linguist\ tool provides repository-level language statistics, breakdowns, and cache management (dump, clear, disable) via subcommands, supporting incremental analysis and specific commit OIDs. The \github-linguist\ tool offers a more modern interface for analyzing repositories or single files, featuring options for JSON output, detailed file breakdowns, and language detection strategy reporting, with support for specific git revisions.

bin · high confidence

Added two new sample ABAP CDS views in the samples directory: a view demonstrating entity associations (linking monster headers to pets) and a view demonstrating the use of input parameters for filtering data. These samples provide concrete examples of how to define relationships and parameterized queries within ABAP CDS.

samples/ABAP CDS · high confidence

Added three new sample files in the samples/BAML directory: clients.baml defines LLM client configurations for OpenAI and Anthropic with retry policies; gen\_schema.baml provides a function to generate BAML schemas from images using Claude; and threads.baml demonstrates classifying Discord support threads with test cases for different resolution statuses.

samples/BAML · high confidence

Added two new Click router configuration files in the samples/Click directory: sr2.click, which implements the SR2 routing protocol with gateway selection, metric flooding, and query handling, and thomer-nat.click, which provides a firewall and NAT configuration based on the mazu-nat example, including IP rewriting, ICMP handling, and port-based access control.

samples/Click · high confidence

Added three new F\* source files to the samples directory: FStar.DependentMap.fsti, which defines an interface for abstract dependent maps with operations like create, update, and concatenation; Hacl.HKDF.fst, which implements the HKDF key derivation function using HMAC primitives; and Hacl.Spec.Bignum.Fmul.fst, which provides formal specifications and lemmas for shift-reduce bignum multiplication.

samples/Fstar · high confidence

Added two new GDB initialization scripts to the samples directory. The \as3.gdbinit\ script provides custom commands (such as \aswhere\, \asframe\, and \aslocal\) to inspect ActionScript stack frames and local variables when debugging AVMplus. The \gdb\_lpc17xx\_program.gdb\ script automates the process of connecting to an OpenOCD server, resetting an LPC17xx microcontroller, and flashing firmware via a hex file.

samples/GDB · high confidence

This change adds a new set of GSC sample scripts to the \samples/GSC\ directory. The \array\_override\_common\ files introduce a system for registering and managing recursive array overrides with notification exclusion capabilities. The \zm\_init.gsc\ file provides initialization logic for zombie AI, including animation state tracking, accuracy settings, and combat variables. Additionally, \math\_shared.gsc\ supplies utility functions for mathematical operations like clamping, linear mapping, and vector comparisons, while \struct.gsc\ defines methods for interacting with script bundles and entity structures. The \\_spiderbot\_ride.csc\ file demonstrates a specific vehicle interaction pattern, registering a callback for the 'spiderbot\_large' vehicle type to handle entry, exit, and associated visual/audio overrides.

samples/GSC · high confidence

Added four new Liquidsoap sample scripts to the samples directory: audio.liq provides multiband compression and DTMF tone generation utilities; http.liq introduces functions for constructing multipart form data and handling HTTP responses; playlist.liq offers a reloadable playlist source with support for normal, random, and randomize modes; and utils.liq adds helper functions for parsing URL arguments and memoizing function results.

samples/Liquidsoap · high confidence

Added several new sample scripts to the Lua samples directory: a Pico-8 cartridge (treegen.p8) demonstrating a space colonization algorithm, Pd\_lua objects for file list parsing and binary file glitching (vidya-file-list-parser.pd\_lua, vidya-file-modder.pd\_lua, h-counter.pd\_lua), a FastCGI launcher for WSAPI applications (wsapi.fcgi), and a .luacheckrc configuration file for Lua code linting.

samples/Lua · high confidence

Added two new MUF sample files to the samples/MUF directory: 39.m, which provides a framework for validating object properties (such as descriptions, exits, and links) and executing programs with permission checks, and cmd-say.muf, which implements a customizable 'say' command with support for first/third-person verbs, quote customization, message splitting, and color filtering.

samples/MUF · high confidence

Added four new sample files to the PowerShell samples directory: ZLocation.psd1 and ZLocation.psm1 (a module for tracking and navigating directory history with tab completion), history.ps1 (a script for saving and searching PowerShell command history), and pwsh-shebang.ps1 (a build script using the pwsh shebang). These samples provide users with examples of module manifests, custom tab expansion, history persistence, and cross-platform script execution.

samples/PowerShell · high confidence

A new QBS module file (common.qbs) has been added to the samples/QML directory. This module defines shared build properties such as build variants, optimization levels, and host/target OS detection logic. It also configures runtime environment variables (PATH, DYLD\_LIBRARY\_PATH, LD\_LIBRARY\_PATH) required for running applications on Windows, macOS, and Unix-like systems, providing a standardized base for QML samples.

samples/QML · high confidence

Added two new Redscript sample files to the \samples/Redscript\ directory. \hideHeadGear.reds\ introduces logic to hide headgear (and optionally other equipment slots) by wrapping and replacing methods on \EquipmentSystemPlayerData\, allowing users to toggle visibility of specific gear areas. \limitedFastTravel.reds\ restricts available fast travel points by filtering \FastTravelPointData\ via \ShouldShowMappinOnWorldMap\ and \ShouldShowMappinInWorld\, and deactivates associated terminals if the point is hidden, with a configuration section allowing users to enable or disable specific travel points.

samples/Redscript · high confidence

Added new SWIG interface files in the samples/SWIG directory to expose C++ libraries to other languages. This includes CGAL\_AABB\_tree.i for the CGAL AABB tree geometry library, constraint\_solver.swig and linear\_solver.swg for the OR-Tools constraint and linear programming solvers (providing Python and C\# bindings respectively), dictionary.i for Python dictionary type handling, and gauss.i for the Gauss library with specific typemaps for JavaScript and C\# arrays.

samples/SWIG · high confidence

Added three new sample applications built with the Slint UI framework: an IoT dashboard featuring a clock and pie charts, a slide puzzle game with theme support, and a todo list manager with sorting and filtering capabilities.

samples/Slint · high confidence

A new sample file, ApiOverviewPage.st, has been added to the StringTemplate samples directory. This file defines a StringTemplate view for an Android API Differences Report, utilizing template directives to conditionally display sections for removed, added, and changed packages, as well as handling cases where no differences are detected.

samples/StringTemplate · high confidence

The samples/Tcl directory now includes new Tcl-based samples: constraint files for FPGA designs (constraints.sdc and constraints.xdc), utility scripts (owh, starfield), a template for module initialization (init.tcl.in), and Tcl packages for stream processing (stream-0.1.tm) and XDG Base Directory handling (xdgbasedir-0.3.tm).

samples/Tcl · high confidence

Added three new sample applications in the Toit programming language: a chatbot implementation using the OpenAI API with conversation history management, a UART log forwarder that buffers and uploads data to Supabase, and a One-Wire bus utility for discovering and interacting with DS18B20 temperature sensors.

samples/Toit · high confidence

The samples/Verilog directory now includes a collection of new Verilog source files and testbenches, such as button\_debounce, control, encrypted\_module, hex\_display, module\_stub, mux, pipeline\_registers, ps2\_mouse, ram, sha-256-functions, sign\_extender, sqrt\_pipelined, and vga. These additions provide users with reference implementations for various hardware components, including debouncers, display controllers, memory modules, cryptographic functions, and interface logic.

samples/Verilog · high confidence

The repository now includes a suite of new scripts to streamline grammar maintenance and validation. \script/add-grammar\ allows developers to easily add or replace grammar submodules, while \script/bootstrap\ automates the initial setup of dependencies and submodules. A new \script/cross-validation\ tool performs leave-one-out classification testing to ensure language detection accuracy, and \script/check-regex-compatibility\ validates that heuristic patterns work consistently across Ruby, Go, and Rust regex engines. Additional utilities include \script/list-grammars\ for updating documentation, \script/sort-submodules\ for maintaining order, and \script/grammar-compiler\ for building grammar artifacts.

script · high confidence

Added sample files to demonstrate syntax highlighting and parsing for TeX bibliography styles (authortitle.cbx, verbose.bbx), TeX localization files (english.lbx), TeX class files (problemset.cls, reedthesis.cls), and TeX table-of-contents files (.toc). Also added samples for World of Warcraft addon manifest files (.toc), including examples with internationalization tags and custom metadata.

samples/TeX · high confidence

Added sample scripts for the NewLisp language, including an IRC client library (irc.lsp), a SQLite database logging utility (log-to-database.lisp), and a N-Queens solver (queens.nl).

samples/NewLisp · high confidence

The Jupyter Notebook sample has been updated from a placeholder to a functional example demonstrating bird counting using morphological image operations from the scipy.ndimage module. The notebook includes a markdown introduction explaining the steps (loading the image, filtering pixels, binary representation, dilation/erosion, and counting) and a code cell that executes these operations, displaying the original image.

samples/Jupyter Notebook · high confidence

A change to existing behaviour in lib/linguist — 3492 commits (187 fixs), 23 files.

lib/linguist · medium confidence · unverified

The \samples/Python/filenames\ sample now includes a \DEPS\ file and a \.gclient\ configuration to manage external dependencies. This change introduces support for the GN configuration language within this sample, allowing the build system to automatically checkout and configure specific versions of Chromium, Node.js, and other libraries like PyYAML and Boto during the build process.

samples/Python/filenames · high confidence

The samples/Jinja directory now includes new Jinja2 template files (home.j2 and worker.jinja2) that provide the HTML structure for the OAuth Client Helper home page and the workers status view. These templates replace the previous Django-style templates, offering a Jinja2-compatible rendering layer for the sample application's UI components.

samples/Jinja · high confidence

The TI Program samples directory now includes several new program files (CIRCLES.8xp, CLOCK.8xp, cowsource.8xp) and source files for the AlphaCS application (srcalpha.8xp.txt, srcfunc.8xp.txt, srcgui.8xp.txt, srcsort.8xp.txt). Additionally, the file extension for the AlphaCS source files has been restored to .8xp.txt to ensure proper highlighting and recognition.

samples/TI Program · high confidence

Added sample files to the Perl language definition to improve recognition of common Perl project artifacts. This includes configuration files such as \.latexmkrc\ and \latexmkrc\ for LaTeX processing, \Makefile.PL\ for Perl module builds, \Rexfile\ for Rex automation, \cpanfile\ for cpanm dependencies, and the \ack\ script itself. These additions ensure that these specific filenames are correctly identified as Perl-related content.

samples/Perl/filenames · high confidence

The C\# sample directory has been significantly expanded to better represent the language's ecosystem and modern features. New samples include a Razor MVC view file (cshtml), a Cake build script (build.cake), and LinqPad scripts (.linq), ensuring these specific file types are correctly identified as C\#. Additionally, the samples now demonstrate modern C\# syntax, such as file-scoped namespaces, and include various utility classes like an HTTP server and MongoDB expression visitors to provide a more comprehensive reference for users.

samples/C\# · high confidence

The Dotenv language definition now recognizes additional common filename variations for environment configuration files, specifically adding \.env.template\ and \.env.sample\ alongside existing patterns like \.env.example\ and \.env.local\. This ensures that these specific sample and template files are correctly identified and syntax-highlighted as Dotenv files rather than generic text.

samples/Dotenv · high confidence

The C language detection samples have been significantly expanded with new source files and headers, including 2D graphics routines, GLKit matrix operations, Git internals, and various utility headers. This addition helps improve the accuracy of C file classification by providing more representative examples for the detector.

samples/C · high confidence

The application now recognizes several additional filenames as INI-format configuration files, including \.buckconfig\, \.coveragerc\, \.flake8\, \.gitreview\, \.pylintrc\, \buildozer.spec\, \pylintrc\, and \vlcrc\. It also adds support for the \hosts\ filename, commonly used for Ansible inventory configurations. This allows these specific files to be parsed and highlighted correctly as INI structures.

samples/INI/filenames · high confidence

The \samples/JSON/filenames\ directory has been updated with new sample files to improve recognition of various JSON-based configuration and lock files. Added samples include \.all-contributorsrc\, \.arcconfig\, \.htmlhintrc\, \.imgbotconfig\, \.releaserc\, \.tern-config\, \.tern-project\, \.watchmanconfig\, \MODULE.bazel.lock\, \bun.lock\, \deno.lock\, \flake.lock\, and \mcmod.info\. These additions ensure that tools can correctly identify and handle these specific file formats as JSON.

samples/JSON/filenames · high confidence

Added sample files to the JSON language definition to improve recognition and syntax highlighting for a wider variety of JSON-based formats. New samples include HAR (HTTP Archive) recordings, SARIF (Static Analysis Results Interchange Format) for code scanning, TopoJSON and GeoJSON for geographic data, glTF for 3D models, Avro schemas, Terraform state files, GameMaker Studio 2 project files (.yy, .yyp), 4D Project/Form files, Minecraft resource pack metadata (.mcmeta), Tact layout files, Web App/Manifest files, and Git commit message language definitions. These additions ensure that files with these specific extensions or structures are correctly identified and highlighted as JSON.

samples/JSON · high confidence

The system now recognizes a broader set of Makefile variants beyond the standard \Makefile\ and \makefile\. This update adds support for specific naming conventions used by different build systems and platforms, including \BSDmakefile\, \Kbuild\, \Makefile.boot\, \Makefile.frag\, \Makefile.inc\, \Makefile.pc\, \Makefile.wat\, \makefile.sco\, and \mkfile\. Users will now see these files correctly identified and highlighted as Makefiles in their projects.

samples/Makefile/filenames · high confidence

The Markdown samples directory now includes additional example files to demonstrate syntax and usage across various formats. New files include \README.mdown\, \minimal.md\, \tender.md\, \livebook.livemd\, \csharp6.workbook\, and several \.ronn\ manpage source files (\bunyan.1.ronn\, \ronn.1.ronn\, \ronn-format.7.ronn\) as well as a \sway.5.scd\ file. This addition supports the recognition of \.mdown\, \.livemd\, \.workbook\, \.ronn\, and \.scd\ extensions as Markdown or Markdown-like content, and includes a symlink \symlink.md\ pointing to \README.mdown\ to test symlink handling.

samples/Markdown · high confidence

The Prolog sample directory has been significantly expanded with new example files, including administrative interfaces, logic problems, and utility modules. This update adds support for the \.pro\ and \.plt\ file extensions, as well as the \.yap\ extension for the YAP Prolog interpreter, allowing users to identify and run samples across different Prolog implementations.

samples/Prolog · high confidence

The tool now recognizes additional TOML-based files, including \Cargo.toml.orig\, \.toml.example\ files, \Gopkg.lock\, \uv.lock\, and \pdm.lock\ (marked as generated). This update is accompanied by new sample files in the \samples/TOML\ directory, such as an example audit configuration (\audit.toml.example\) and lock files for Rust (\Cargo.toml.orig\), Go (\Gopkg.lock\), and Python (\pdm.lock\, \uv.lock\), ensuring these formats are correctly identified and handled.

samples/TOML · high confidence

The 'JSON with Comments' language definition now recognizes a broader set of configuration files, including \.babelrc\, \.eslintrc\, \.eslintrc.json\, \.jscsrc\, \.jshintrc\, \.jslintrc\, \.oxlintrc.json\, \.swcrc\, \devcontainer.json\, \jsconfig.json\, \tsconfig.json\, and \tslint.json\. This ensures that these specific configuration files are correctly identified and syntax-highlighted as JSON with comments in supported editors.

samples/JSON with Comments/filenames · high confidence

The 'JSON with Comments' syntax definition now includes a broader range of sample files to demonstrate its support for comment-enabled JSON variants. New samples include configuration files such as \coc.jsonc\, \jest.tsconfig.json\, \plyr.code-workspace\, and \vue.code-snippets\, alongside other JSON-based formats like \AMPL.sublime-build\, \CLIPS.sublime-settings\, \Dart.sublime-commands\, \Dart.sublime-project\, \Context.sublime-menu\, \Default (Linux).sublime-mousemap\, \Default.sublime-keymap\, \JavaDoc Add Line.sublime-macro\, \Mariana.sublime-color-scheme\, \RunBuild.sublime-macro\, \SourcePawn.sublime-build\, \Tubnil.sublime-theme\, and \jade.sublime-completions\. This ensures that users can see how the syntax handles comments in these diverse file types.

samples/JSON with Comments · high confidence

The repository's interaction with Git is now mediated through a new \Linguist::Source\ interface, decoupling core logic from the underlying \Rugged\ library. This change introduces a \Repository\ interface and a \RuggedRepository\ implementation, along with a \Diff\ abstraction for iterating over file changes. For users, this provides a more robust foundation for handling repository data, specifically addressing stability against malformed repositories (git bombs) by enforcing limits on tree traversal and blob loading within the new abstraction.

lib/linguist/source · high confidence

The sample scripts in the samples/Zeek directory have been updated to use the Zeek scripting language, replacing the previous Bro language files. This includes new .zeek versions of the example script, the base DNS analysis module, and the base HTTP analysis module, ensuring compatibility with the Zeek platform.

samples/Zeek · high confidence

The linguist library now includes a new C extension (linguist) that replaces the previous pure-Ruby tokenizer with a flex-based scanner. This change introduces a native \Linguist::Tokenizer\ class with an \extract\_tokens\ method, which leverages the \lex.linguist\_yy.c\ and \lex.linguist\_yy.h\ files generated by flex 2.6.4 to parse source code. The extension is built via \extconf.rb\ and defines tokenization rules in \tokenizer.l\, including support for various comment styles and token length limits, aiming to provide faster and more robust language detection.

ext · high confidence

The \tools/grammars\ directory now contains a new grammar compiler written in Go, replacing the previous tooling. This compiler processes TextMate grammar sources (\.json\, \.cson\, \.plist\, \.yaml-tmlanguage\) and outputs compiled grammar definitions in Protocol Buffer and JSON formats. It introduces stricter validation, including support for new grammar fields like \$schema\, \hideFromUser\, and \injectionSelector\, while treating certain warnings as non-fatal. The build environment is containerized via a Dockerfile using Go 1.20 and Node.js 22, and includes a CLI for adding, updating, and compiling grammars.

tools · high confidence

The language detection logic has been restructured into distinct, modular strategy classes (Extension, Filename, Manpage, Modeline, and XML) within the \lib/linguist/strategy\ directory. This change introduces specific detection capabilities: the Extension strategy now loads generic file extensions from a dedicated \generic.yml\ configuration file; the Modeline strategy has been rewritten with improved, case-insensitive regular expressions for both Emacs and Vim modelines, limited to searching the first and last 5 lines of a file; the Manpage strategy adds support for detecting Roff man pages via numeric extensions; and the XML strategy detects files based on the presence of an XML root tag. These strategies are designed to be composable, allowing the detection pipeline to consider results from previous strategies.

lib/linguist/strategy · high confidence

The core language detection logic has been restructured from a monolithic implementation into a chain of distinct strategies (Modeline, Filename, Shebang, Extension, XML, Manpage, Heuristics, Classifier) that are executed sequentially until a single language candidate is identified. This change introduces an instrumentation interface, allowing users to hook into detection events (such as strategy execution and final detection) for monitoring and debugging purposes, while also adding specific detection strategies for Roff man pages and XML files.

lib · high confidence

The sample located at samples/Wikitext has been renamed from MediaWiki to Wikitext. This change updates the directory structure and associated documentation files (such as README.wiki and mediawiki.mediawiki) to reflect the new naming convention, aligning the sample's identity with its broader Wikitext context.

samples/Wikitext · high confidence

The samples directory previously named Mathematica has been renamed to Wolfram Language. This change reflects the official rebranding of the Wolfram Language and Mathematica product, updating the directory structure to align with current naming conventions while preserving all existing sample code and functionality.

samples/Wolfram Language · high confidence

The sample code has been split into distinct folders for ASP.NET and Classic ASP. The ASP.NET section now includes a complete web application structure with an EchoSocket handler, login page, and OpenAuth providers, while the Classic ASP section contains unit test runners and XML content examples. This separation clarifies the technology-specific examples for users.

samples/ASP.NET, samples/Classic ASP · high confidence

The sample code for the Cairo language has been reorganized into two distinct directories: 'Cairo' and 'Cairo Zero'. This change separates samples targeting the modern Cairo 1.0 compiler (e.g., \boolean.cairo\, \pizza\_factory.cairo\, \rlp.cairo\) from those targeting the legacy Cairo Zero compiler (e.g., \casm.cairo\, \concat\_arr.cairo\, \contract.cairo\). Users should now look in the respective directory for samples compatible with their specific compiler version.

samples/Cairo, samples/Cairo Zero · high confidence

The Cirru sample files in the samples/Cirru directory have been replaced with new content. The updated samples now include a comprehensive webpack configuration (webpack.config.cirru) demonstrating module rules for Cirru, CSS, and images, as well as a detailed HTML template sample (template.cirru) illustrating structure and styling. Additional samples cover various language features such as folding, indentation, parentheses, and quoting, providing updated examples for users.

samples/Cirru · high confidence

The Dart sample files in the samples/Dart directory have been regenerated and updated to follow current best practices. This includes new protobuf-generated files (addressbook.pb.dart, addressbook.pbenum.dart, addressbook.pbjson.dart) targeting Dart 3.3, a new freezed-based equality sample (equals.dart), and a simplified point calculation example (point.dart).

samples/Dart · high confidence

The Eagle hardware design files (Eagle.brd and Eagle.sch) in the samples/Eagle directory have been reordered to align with the placement structure in the main Samples directory. This change ensures the sample project's file organization is consistent with the broader project layout, facilitating easier navigation and reference for users exploring the hardware design examples.

samples/Eagle · medium confidence

The vendor directory has been updated with a new CodeMirror submodule and a refreshed index of syntax highlighting grammars in README.md. This update includes new or replaced grammars for a wide range of languages and file types, such as ArkTS, Bend, SpiceDB Schema, Quint Specification, and BAML, ensuring that code in these formats is correctly highlighted on the platform.

vendor · high confidence

Added four new TSX sample files (import.tsx, react-native.tsx, require.tsx, triple-slash-reference.tsx) to the samples/TSX directory. These files serve as fixtures for testing TSX parsing and handling, addressing issue \#4359.

samples/TSX · high confidence

Add test fixtures for language detection and modeline parsing; Added Jest snapshot tests for CSS styling in SVG samples; Added Terra sample tests for arithmetic, arrays, and N-body simulation; Added Texinfo documentation for the ruby-debug-ide protocol; Added Turing language sample programs; Added sample RPM spec files for Apache, ErlyDTL, and Manos.

The project now manages its Ruby dependencies via a Gemfile and github-linguist.gemspec, pinning runtime dependencies like charlock\_holmes (\~\> 0.7.7), mini\_mime (\~\> 1.0), and rugged (\~\> 1.0), alongside development tools such as minitest, mocha, and licensed. Additionally, a go.work file establishes a Go 1.20 workspace that includes the tools/grammars directory, aligning the local development environment with the Go-based grammar compiler.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 68 → 60 (-8.2)
• Rubric changed (rubric-2026.09.15 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 66 → 92 (+25.2)
• Architecture 90 → 67 (-22.4)
• Maturity 64 → 64 (+0.0)
• Readiness 80 → 51 (-28.4)
• Security 71 → 67 (-4.8)

• Ambiguous naming overlap. binary? and likely_binary? appear to serve very similar purposes (determining if content is binary). The distinction between 'binary' and 'likely binary' is not immediately obvious from the signature alone and suggests inconsistent confidence levels or logic paths for the same domain question.
• Implicit redundancy. BlobHelper.empty?() checks if the blob has no content, which is semantically equivalent to checking if Blob.size() == 0. Exposing both allows for inconsistent usage patterns (some users call empty?, others check size).
• Off-boarding risk: anonymized user #1
• Redundant abstraction layer. LazyBlob exposes a language() method that delegates to BlobHelper (or similar internal logic), but BlobHelper is also a public type with its own language() method. This creates two entry points for the same logical operation (determining the language of a blob), confusing users about whether they should interact with the Blob wrapper or the Helper directly.

• Ambiguous and overlapping binary detection methods. BlobHelper.binary? and BlobHelper.likely_binary? appear to serve similar purposes (detecting binary content) with unclear distinction. Blob.binary_mime_type? is a specific check for MIME type, while Delta.binary? checks diff status. The presence of both binary? and likely_binary? on the same object suggests a lack of clear semantic separation between 'definitively binary' and 'probabilistically binary'.
• Converter.AddGrammar (cognitive 19) (tools/grammars/compiler/converter.go)
• Converter.Report (cognitive 19) (tools/grammars/compiler/converter.go)
• Duplicated block (9 lines × 2) (samples/Java/GrammarKit.java)
• Generated.generated? (cognitive 73) (lib/linguist/generated.rb)
• Generated.generated? (cyclomatic 74) (lib/linguist/generated.rb)
• Inconsistent lookup method naming and signature. Language. is a generic accessor that likely delegates to one of the specific finders, but its behavior is undocumented in the signature. The specific finders (find_by_name, find_by_alias, etc.) are verbose and inconsistent with the concise Language.[] syntax. Additionally, find_by_extension takes a filename argument, which is confusing.
• Inconsistent predicate naming for file characteristics. empty?, large?, text?, image?, csv?, pdf? are clear. However, solid? is ambiguous (does it mean 'non-empty'? 'binary'? 'dense'?).
• Inconsistent return types and scope for language queries. BlobHelper.language() and LazyBlob.language() return a single Language object (or nil). Repository.language() is ambiguous: does it return the dominant language or the language of the repo itself? Repository.languages() returns a breakdown. The naming language() vs languages() is consistent, but Repository.language() is semantically unclear compared to Repository.breakdown_by_file() or Repository.languages().
• Off-boarding risk: anonymized user #1
• Redundant MIME type methods. mime_type() and content_type() likely return the same value (MIME type). _mime_type() is a private/internal method (indicated by underscore) but is exposed in the public API surface. Having both mime_type and content_type is redundant as they are synonyms in HTTP/Content contexts.
• TooManyMethods: BlobHelper (lib/linguist/blob_helper.rb)
• TooManyMethods: Generated (lib/linguist/generated.rb)
• fsLoader.load (cognitive 16) (tools/grammars/compiler/loader_fs.go)
• main.main (cognitive 20) (tools/grammars/cmd/grammar-compiler/main.go)
• main.main (cyclomatic 17) (tools/grammars/cmd/grammar-compiler/main.go)
• urlLoader.loadTarball (cognitive 18) (tools/grammars/compiler/loader_url.go)

• 3 commits — 3 feature/other, 0 fixes

• test/fixtures — 2 commits
• lib/linguist — 1 commit

• change: Add RPM Spec heuristic for .spec files (#8178)
• change: Recognize GLSL .frag shaders (#8233)
• change: Recognize HLSL .fx effect techniques and shader semantics (#8184)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

github-linguist/linguist was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.