Skip to content
CAI
Software that uses CAICheck a score

joernio/joern

50.8

Adequate · 14 November 2026

115.8k

lines of production code

Scala

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add ARM function parsing pass for Ghidra frontend

The Ghidra frontend now includes a dedicated ArmFunctionPass to handle ARM architecture binaries. This new pass extends the base FunctionPass and utilizes the ArmProcessor to parse functions, creating the corresponding method, block, and return nodes in the Code Property Graph (CPG). It also handles function parameters and local variables, ensuring that ARM-specific code is correctly decompiled and represented in the analysis graph.

joern-cli/frontends/ghidra2cpg/src/main/scala/io/joern/ghidra2cpg/passes/arm · high confidence

Add CFR-based decompilation and recursive JAR unpacking support

The jimple2cpg frontend now supports decompiling Java class files using CFR when Jimple source is unavailable, and handles nested archives (JARs inside JARs) with configurable recursion depth. This allows the tool to process more complex inputs by extracting and analyzing classes from deeply nested archives, while also emitting configuration files found during unpacking.

joern-cli/frontends/jimple2cpg/src/main/scala/io/joern/jimple2cpg/util · high confidence

Add EJS template preprocessing support

The JavaScript source-to-CPG frontend now supports preprocessing EJS template files. A new EjsPreprocessor class handles EJS-specific syntax by stripping script tags, ignoring comments and includes, and transforming output tags (like \<%= and \<%-) into fake function calls to ensure they are correctly detected as sinks in the control flow graph.

joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/preprocessing · high confidence

Add Kotlin frontend (kotlin2cpg) with Bazel build support

Introduces the kotlin2cpg frontend, enabling users to analyze Kotlin source code. This change adds the Bazel build configuration (BUILD file) for compiling the frontend and its tests, along with shell scripts (kotlin2cpg.sh) and a launcher script (jar\_from\_aar.sh) to facilitate running the tool and handling Android Archive dependencies.

joern-cli/frontends/kotlin2cpg · high confidence

Add Kotlin-specific scope management for closure variable capture

The Kotlin frontend now includes a dedicated Scope class that extends the shared X2CpgScope base to handle closure scopes. This change introduces a pushClosureScope method that captures variables from existing stack entries, deduplicates them by name, and returns the list of captured variables when a new closure scope is pushed, ensuring correct variable scoping for Kotlin closures.

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/datastructures · high confidence

Add general-purpose utility scripts for code analysis

New scripts have been added to the general category to assist with code analysis workflows. The \list-funcs.sc\ script allows users to retrieve a list of all method names from the currently loaded Code Property Graph (CPG). Additionally, \help.sc\ and \run.sc\ provide validation checks to ensure help text is available and that the base layer has been correctly applied, respectively. A \scripts.json\ manifest has also been introduced to register these scripts within the CLI's general script collection.

joern-cli/src/main/resources/scripts/general · high confidence

Add php2cpg frontend for PHP to CPG conversion

Users can now convert PHP source code into Code Property Graphs (CPG) using the new php2cpg frontend. This tool relies on the php-parse library to generate JSON ASTs from PHP files (requiring PHP \>=7.0), which are then converted into CPGs. The change introduces the build configuration (BUILD), entry-point scripts (php2cpg.sh, php2cpg.bat), and documentation (README.md) necessary to build and run this specific frontend.

joern-cli/frontends/php2cpg · high confidence

Added MSVC support and improved system header auto-discovery in C2C

The C2C frontend now supports automatic discovery of system include paths for MSVC projects on Windows, in addition to the existing GCC support. This change introduces a new \GccSpecificExternalCommand\ utility to handle external command execution and updates \IncludeAutoDiscovery\ to detect MSVC installations via \vswhere.exe\ and \vcvars64.bat\, ensuring that C and C++ headers are correctly resolved for Visual Studio projects. It also includes a workaround for a Windows-specific issue where GCC header discovery commands return an unexpected exit code.

joern-cli/frontends/c2cpg/src/main/scala/io/joern/c2cpg/utils · high confidence

Added script runner documentation and test utilities

The scripts directory now includes a README explaining how to use the \runScript\ method to execute scripts within a Joern session, along with utility scripts for testing: \assertions.sc\ provides an \assertContains\ helper for validating script outputs, and \trigger-error.sc\ is a simple script designed to throw an exception for testing error handling.

joern-cli/src/main/resources/scripts · high confidence

C\# frontend AST creation implementation

The C\# source-to-CPG frontend now includes the core AST creation logic in the \astcreation\ package. This implementation handles the translation of C\# source code into the Code Property Graph, covering top-level statements, class and record declarations, method signatures, and control flow structures like loops and switch statements. It also supports expression handling, including member access, property setters, and type resolution, enabling the frontend to parse and analyze C\# codebases.

joern-cli/frontends/csharpsrc2cpg/src/main/scala/io/joern/csharpsrc2cpg/astcreation · high confidence

C\# frontend adds comprehensive control-flow AST generation and program summary infrastructure

The C\# frontend now generates Abstract Syntax Tree (AST) nodes for a wide range of control-flow statements, including if-else, switch (with pattern matching), for, foreach, do-while, while, try-catch-finally, using, and throw statements. This is implemented via a new \AstForStatementsCreator\ trait that maps these C\# constructs to the Code Property Graph. Additionally, a new \CSharpProgramSummary\ data structure and associated logic have been introduced to manage type stubs, imports, and global using directives, enabling better type resolution and dependency summarization for C\# code analysis.

csharpsrc2cpg · high confidence

C\# frontend adds dependency downloading, implicit usings support, and AST generation utilities

The C\# frontend now automatically downloads and summarizes NuGet dependencies to improve symbol resolution, supports implicit global usings defined in .csproj files (including Include/Remove directives), and introduces a dedicated runner for the dotnetastgen tool to handle native binary execution and output parsing. These changes are implemented in new utility classes (DependencyDownloader, ImplicitUsingsCollector, DotNetAstGenRunner, ProgramSummaryCreator) alongside helper functions for method signature composition and top-level statement handling.

joern-cli/frontends/csharpsrc2cpg/src/main/scala/io/joern/csharpsrc2cpg/utils · high confidence

C\# frontend introduces AST and dependency parsing passes

The C\# frontend now includes dedicated passes for generating the Control Flow Graph (AST) and extracting project dependencies. The new AstCreationPass processes source files in parallel to build the AST, while the DependencyPass parses C\# project files (XML) to extract package references and versions, registering them as dependency nodes in the code property graph.

joern-cli/frontends/csharpsrc2cpg/src/main/scala/io/joern/csharpsrc2cpg/passes · high confidence

Distribution includes launcher scripts for new language frontends and CLI tools

The joern-cli distribution now ships with executable wrapper scripts for a broad set of language frontends (abap2cpg, c2cpg, csharpsrc2cpg, ghidra2cpg, gosrc2cpg, javasrc2cpg, jimple2cpg, jssrc2cpg, kotlin2cpg, php2cpg, pysrc2cpg, rubysrc2cpg, rust2cpg, swiftsrc2cpg) and core CLI commands (joern, joern-cpg2scpg, joern-export, joern-flow, joern-parse, joern-scan, joern-slice, joern-vectors). These scripts ensure the frontends and tools are launched with consistent JVM options (G1GC, 128m compressed class space, log4j2 config) and handle platform-specific path resolution, making these capabilities immediately available in the installed distribution.

joern-cli/src/universal · high confidence

Extract constants and add Java source interop support

The Kotlin frontend now centralizes internal string literals (such as operator suffixes, iterator method names, and destructuring prefixes) into a new Constants object, improving maintainability. Additionally, a new JavaSrcInterop object is introduced to facilitate the creation of AST passes for Java source code, enabling better integration between Kotlin and Java source analysis within the CPG.

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg · high confidence

Ghidra2cpg frontend integration and startup script

The ghidra2cpg frontend is now integrated as a single project within the build, accompanied by a new README detailing setup requirements (OpenJDK 11, sbt) and known issues, along with a shell script (ghidra2cpg.sh) that serves as the entry point to execute the staged binary.

joern-cli/frontends/ghidra2cpg · high confidence

Go frontend introduces initial AST creation and dependency processing passes

The Go source-to-CPG frontend now includes a set of new processing passes to handle the initial stages of code analysis. This adds \AstCreationPass\ for generating the main Abstract Syntax Tree from Go source files, \InitialMainSrcPass\ and \DependencySrcProcessorPass\ for building pre-processing caches from main and dependency sources respectively, and \PackageCtorCreationPass\ to handle package-level constructors. Additionally, \DownloadDependenciesPass\ is introduced to automatically fetch and process Go module dependencies, enabling the frontend to analyze code that relies on external packages.

joern-cli/frontends/gosrc2cpg/src/main/scala/io/joern/gosrc2cpg/passes · high confidence

Go source-to-CPG frontend adds AST generation runner and utility constants

The Go frontend now includes a dedicated AST generation runner (GoAstGenRunner) that executes the external goastgen binary, handles platform-specific binaries (Windows, Linux, macOS on x86/ARM), filters input files, and segregates parsed results by Go module structure. Additionally, a new Constants file provides utility patterns for file separators and operator identifiers, supporting the underlying AST generation and parsing logic.

joern-cli/frontends/gosrc2cpg/src/main/scala/io/joern/gosrc2cpg/utils · high confidence

Improved MIPS data-flow tracking for Lo/Hi registers and return values

The ghidra2cpg MIPS frontend now adds explicit data-flow edges for architecture-specific behaviors. A new LoHiPass creates REACHING\_DEF edges linking instructions that write to the MIPS Lo/Hi registers (e.g., div, mul) to those that read from them (e.g., mflo, mfhi), enabling better tracking of intermediate calculation results. Additionally, a new MipsReturnEdgesPass connects call sites to their return values by linking calls to the specific v0/v1 register arguments, improving the accuracy of return value analysis in the generated code property graph.

joern-cli/frontends/ghidra2cpg/src/main/scala/io/joern/ghidra2cpg/passes/mips · high confidence

Improved type resolution for Java modules and JAR archives

The Java source-to-CPG frontend now includes a new \JarTypeSolver\ that enhances type resolution by properly handling JAR and JMOD archives, as well as the Java runtime image (\lib/modules\). This change ensures that type information is correctly extracted from module exports and bytecode, reducing unresolved symbol errors when analyzing code that depends on external libraries or JDK internals.

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/typesolvers/noncaching · high confidence

Initial ABAP AST creation logic for method declarations, parameters, and expressions

The ABAP frontend now includes the core AST creation logic for converting ABAP source code into the Code Property Graph. This change introduces the implementation for parsing method declarations (including IMPORTING, EXPORTING, CHANGING, and RETURNING parameters), handling local variable declarations, and processing expressions such as method calls, operator calls, field accesses, identifiers, and literals. Users can now analyze ABAP code structures that involve method signatures and basic expression evaluation within the AST.

joern-cli/frontends/abap2cpg/src/main/scala/io/joern/abap2cpg/astcreation · high confidence

Initial Bazel build support for pysrc2cpg frontend

The pysrc2cpg frontend now includes a Bazel build configuration (BUILD file) that defines the Scala library, Java CC parser generation, test targets, and distribution packaging. This change introduces experimental Bazel build system support, allowing the frontend to be built and tested using Bazel alongside existing build methods.

joern-cli/frontends/pysrc2cpg · high confidence

Initial Bazel build support for x2cpg

The x2cpg module now includes a BUILD file and associated Java/Scala sources to enable building with the Bazel build system. This introduces a dedicated java\_library rule to handle annotation processing dependencies, a scala\_library rule for the main x2cpg code, and a scala\_test rule for the test suite. It also adds Java-specific runfiles locator implementations to support Bazel's runfiles mechanism, distinct from the SBT build's empty implementation. Additionally, test resources including PHP function signatures and C test code are included to support the new build configuration.

joern-cli/frontends/x2cpg · high confidence

Initial C\# JSON AST parser infrastructure

The C\# frontend now includes a new JSON-based AST parser layer. This introduces a comprehensive type hierarchy in \DotNetJsonAst\ covering C\# language constructs such as statements, expressions, types, and literals, alongside a \DotNetJsonParser\ to read and structure the JSON input. This provides the foundational data structures required for subsequent AST-to-CPG translation.

joern-cli/frontends/csharpsrc2cpg/src/main/scala/io/joern/csharpsrc2cpg/parser · high confidence

Initial Go source-to-CPG frontend AST creation logic

The \gosrc2cpg\ frontend now includes the core AST creation implementation in the \astcreation\ package. This adds the \AstCreator\ class and supporting traits (such as \AstForExpressionCreator\, \AstForFunctionsCreator\, and \AstForStatementsCreator\) that parse Go source JSON and generate Code Property Graph nodes for expressions, functions, statements, and type declarations. This change enables the tool to construct the initial structural representation of Go code for analysis.

joern-cli/frontends/gosrc2cpg/src/main/scala/io/joern/gosrc2cpg/astcreation · high confidence

Initial PHP frontend AST creation implementation

The PHP frontend (php2cpg) now includes the core AST creation logic, enabling the conversion of PHP source code into the Code Property Graph. This implementation covers the parsing and graph generation for a wide range of PHP language constructs, including control structures (if, while, for, foreach, switch, try-catch), expressions (binary/unary operators, casts, ternary, match, yield), declarations (classes, methods, closures, namespaces, traits, enums), and statements (echo, unset, global, use). It also handles specific PHP features such as static method resolution, closure variable capture, and array unpacking, while managing file content encoding and scope resolution to ensure accurate dataflow and call graph analysis.

joern-cli/frontends/php2cpg/src/main/scala/io/joern/php2cpg/astcreation · high confidence

Initial configuration for ABAP frontend

The ABAP frontend now includes its default configuration files. The application configuration sets the ABAP AST generator version to 0.5.1, and logging is configured to output to the console with a color-coded pattern, defaulting to the INFO level unless overridden by the SL\_LOGGING\_LEVEL environment variable.

joern-cli/frontends/abap2cpg/src/main/resources · high confidence

Initial implementation of the JavaScript/TypeScript source-to-CPG frontend

The \jssrc2cpg\ frontend is introduced, providing the core AST creation logic for converting JavaScript and TypeScript source code into the Code Property Graph. This change adds the \AstCreator\ and its supporting traits (handling declarations, primitives, statements, template/JSX DOM elements, and type helpers) which parse Babel AST nodes and map them to CPG nodes, including support for TypeScript-specific features like type assertions, decorators, and module exports.

joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation · high confidence

Initial implementation of the jssrc2cpg JavaScript/TypeScript frontend

The jssrc2cpg frontend is introduced to parse JavaScript and TypeScript source files into the Code Property Graph. This change adds the core AST creation logic, including support for call expressions, this expressions, new expressions, member expressions, and assignment operators, as well as handling function parameters (including rest elements, default values, and destructuring) and TypeScript type aliases. It also includes the Babel JSON parser to ingest pre-parsed ASTs and load associated type maps.

jssrc2cpg · high confidence

Initial implementation of the jssrc2cpg frontend passes

This change introduces the core processing pipeline for the new JavaScript/TypeScript frontend (jssrc2cpg) within the Joern CLI. It adds a suite of passes that handle the end-to-end creation of the Code Property Graph (CPG) for JavaScript projects: AstCreationPass manages the parallel parsing of source files using astgen and Babel; ConfigPass identifies and ingests configuration files (including .pug, .vue, and .html); DependenciesPass extracts dependency metadata from package.json files; ImportsPass resolves CommonJS require statements; and JavaScriptMetaDataPass records project metadata. Additionally, it includes specialized passes for handling private key files securely, managing type node naming conventions, and defining EcmaScript built-ins.

joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/passes · high confidence

Initial instruction mapping support for ARM, MIPS, X86, and PCode in ghidra2cpg

The ghidra2cpg frontend now includes processor-specific instruction mappers for ARM, MIPS, X86, and Ghidra's PCode intermediate representation. These new files define how specific assembly instructions and PCode operations are translated into Code Property Graph (CPG) operators (such as assignments, calls, and control flow), enabling the tool to analyze binaries for these architectures.

joern-cli/frontends/ghidra2cpg/src/main/scala/io/joern/ghidra2cpg/processors · high confidence

Initial parser infrastructure for Go source-to-CPG conversion

The Go source frontend now includes a new parser layer that reads Go AST JSON output and maps it to internal node types. This adds GoAstJsonParser to deserialize AST JSON and go.mod files, ParserAst to define the set of supported Go AST node types (expressions, statements, primitives, declarations), and ParserNodeInfo to carry node metadata such as source location and code snippets.

joern-cli/frontends/gosrc2cpg/src/main/scala/io/joern/gosrc2cpg/parser · high confidence

Initial release of Joern Query Database with Android security scanners

The querydb module is introduced as the central query database for Joern, providing a standalone library of security and metrics queries that can be used with or without the full Joern installation. This release includes a new Android query bundle containing scanners for critical vulnerabilities such as arbitrary file writes, external storage code execution, intent-based command injection, insecure JavaScript interfaces, and misconfigurations like tap-jacking and backup exposure. It also adds a \dumpq\ utility to export the query database to JSON and establishes the foundational structure for query bundles, tags, and author metadata.

querydb · high confidence

Initial release of jssrc2cpg JavaScript/TypeScript frontend

Adds the jssrc2cpg frontend, a Babel-based parser that generates Code Property Graphs for JavaScript and TypeScript source code. The change introduces the build configuration (BUILD), a launcher script (jssrc2cpg.sh), and documentation (README.md) for the tool, which relies on native astgen binaries to parse source files.

joern-cli/frontends/jssrc2cpg · high confidence

Initial release of the Go source-to-CPG frontend

Adds the \gosrc2cpg\ tool, enabling users to convert Go source code into the Code Property Graph (CPG). The frontend parses Go modules, optionally fetches direct or indirect dependencies for enhanced type information, and generates AST nodes for constructs such as for-loops, package-level variables, and type declarations.

joern-cli/frontends/gosrc2cpg/src/main/scala/io/joern/gosrc2cpg · high confidence

Initial release of the JavaScript/TypeScript source-to-CPG frontend

Introduces the \jssrc2cpg\ frontend, enabling users to convert JavaScript and TypeScript source code into the Code Property Graph (CPG). The tool leverages an AST generation runner to parse source files and applies a series of passes—including AST creation, type recovery, import resolution, and dependency analysis—to build the graph. Users can invoke the tool via the command line, with support for disabling TypeScript type generation through the \--no-tsTypes\ flag. Also in this area: Frontend post-processing passes now run as layers.

joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg · high confidence

Initial release of the Rust2CPG frontend

This change introduces the Rust2CPG tool, enabling users to convert Rust source code into a Code Property Graph (CPG) for analysis. The frontend parses Rust files using an external AST generator and constructs the CPG through a series of passes, including AST creation, type node generation, and configuration file handling. Users can control the conversion process via command-line options to skip sysroot loading or bypass the resolution of \#\[cfg(...)\] attributes, providing flexibility for faster processing or specific configuration needs.

joern-cli/frontends/gosrc2cpg, kotlin2cpg · high confidence

Initial release of the Rust2CPG frontend

This change introduces the Rust2CPG tool, enabling users to convert Rust source code into a Code Property Graph (CPG) for analysis. The frontend parses Rust files using an external AST generator and constructs the CPG through a series of passes, including AST creation, type node generation, and configuration file handling. Users can control the conversion process via command-line options to skip sysroot loading or bypass the resolution of \#\[cfg(...)\] attributes, providing flexibility for faster processing or specific configuration needs. Also in this area: Rust frontend updates AST generator and optimizes file content handling; New Rust JSON parser and AST node syntax extensions.

rust2cpg · high confidence

Initial release of the Swift source-to-CPG frontend

This change introduces the \swiftsrc2cpg\ frontend, a new tool that parses Swift source code and generates Code Property Graphs (CPG). It relies on the \SwiftAstGen\ binary (bundled at version 0.4.4) to extract the AST, which is then processed by a suite of Scala passes to create nodes for declarations, expressions, statements, and types. The frontend supports command-line options for defining macros, enabling early schema validation, and optionally using the Swift compiler (\--swift-build\) to retrieve full type information. It also includes build configuration for Bazel and standard logging setup.

joern-cli/frontends/swiftsrc2cpg · high confidence

Initial scaffolding for the Ruby source-to-CPG frontend

The \joern-cli/frontends/rubysrc2cpg\ directory is introduced with the foundational build and configuration files for the new Ruby frontend. This includes a Bazel \BUILD\ file defining the Scala library, test suite, and binary distribution, alongside a \.gitignore\ to manage generated artifacts like type stubs and the embedded \ruby\_ast\_gen\ binary. A shell script (\rubysrc2cpg.sh\) is added to launch the application with the correct logging configuration, and a \README\ documents the dependency on the \parser\ Gem and the embedded AST generator.

joern-cli/frontends/rubysrc2cpg · high confidence

Introduce ABAP Code Property Graph frontend

Adds a new frontend that converts ABAP source files into a Code Property Graph (CPG) for analysis with Joern. The implementation includes a shell wrapper (abap2cpg.sh) to invoke the converter, which relies on external abapgen binaries to parse ABAP into JSON and then transforms that into CPG nodes via Scala passes. Documentation (README.md, architecture.md) is provided to guide users through building the frontend, generating the CPG, and running queries such as finding authorization checks or potential command injection vulnerabilities. Also in this area: Fixes ABAP frontend crashes caused by missing type declarations.

joern-cli/frontends/abap2cpg, joern-cli/frontends/abap2cpg/src/main/scala/io/joern/abap2cpg/passes · high confidence

Introduce ABAP frontend parser and AST generation runner

The ABAP frontend now includes a dedicated parser and AST generation runner. The new AbapAstGenRunner handles invoking the abapgen binary and manages platform-specific binaries, while the AbapJsonParser processes the JSON output from the underlying JavaScript parser to construct an intermediate AST, including logic for grouping classes, methods, and standalone forms.

joern-cli/frontends/abap2cpg/src/main/scala/io/joern/abap2cpg/parser · high confidence

Introduce ABAP intermediate AST data structures

This change adds the core data model for the ABAP parser within the abap2cpg frontend. It defines the \AbapIntermediateAst\ object containing case classes for representing ABAP language constructs, including \ClassDef\, \MethodDef\, \StatementList\, \CallExpr\, and various expression types like \IdentifierExpr\ and \LiteralExpr\. These structures serve as the intermediate representation that the parser will populate before converting to the Code Property Graph.

abap2cpg · high confidence

Introduce C2CPG AST creation implementation

The C2CPG frontend now includes its own AST creation logic, implemented in the \AstCreator\ class and a set of focused traits (\AstForExpressionsCreator\, \AstForFunctionsCreator\, \AstForInitializersCreator\, \AstForPrimitivesCreator\, \AstForStatementsCreator\, and \AstForTypesCreator\). This new implementation translates the Eclipse CDT AST into the Code Property Graph, handling C and C++ constructs such as binary and unary expressions, function declarations and definitions, initializers, identifiers, control flow statements, and type declarations. It also introduces scope-local unique naming for anonymous entities, safe handling of CDT resolution errors (including \StackOverflowError\), and support for C++17/20 features like structured bindings, lambdas, and fold expressions. Also in this area: Enum constants are now represented as field accesses on the enum type; Improved C++ AST accuracy for typedefs, static modifiers, and template aliases; Fix structured binding handling at namespace scope; c2cpg: introduce JSON Compilation Database support and refactor AST creation.

c2cpg, joern-cli/frontends/c2cpg/src/main/scala/io/joern/c2cpg/astcreation · high confidence

Introduce Kotlin CPG type system and call classification

The kotlin2cpg frontend now includes a dedicated types package that establishes the foundational type handling for the Code Property Graph. This adds a \CallKind\ enumeration to distinguish between static, dynamic, extension, and unknown calls, and introduces a \TypeInfoProvider\ that leverages the Kotlin compiler's binding context to accurately classify these call types and resolve property descriptors. A \NameRenderer\ is added to translate Kotlin type descriptors into Java-compatible full names, including mapping Kotlin primitives to their Java equivalents and handling nested class naming conventions. Additionally, a \ContentSourcesPicker\ is provided to intelligently identify source directories by analyzing the project structure for \.kts\ files, and \TypeConstants\ define standard type identifiers used throughout the analysis.

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/types · high confidence

Introduce PHP frontend parser infrastructure and symbol resolution

Adds the core parsing and analysis components for the new php2cpg frontend. This includes the Domain model and PhpParser to interpret PHP-Parser JSON output into internal AST nodes, a ClassParser to extract high-level symbol information, a SymbolSummaryPass to resolve namespaces and imports, and a DependencyPass to parse composer.json files for project dependencies.

php2cpg · high confidence

Introduce c2cpg frontend for C/C++ code analysis

Adds the c2cpg frontend, a new tool that parses C and C++ source code into Code Property Graphs using the Eclipse CDT parser. This release includes support for various C++17 and C++20 language features (such as folding expressions, inline variables, and constexpr if), provides a self-published version of the cdt-core dependency for easier integration, and supplies build scripts (Bazel and sbt) along with a CLI entry point for generating CPGs from C/C++ projects.

joern-cli/frontends/c2cpg · high confidence

Introduce experimental Bazel build system

Adds an experimental Bazel build configuration (MODULE.bazel, BUILD, .bazelrc) to complement the existing SBT build, enabling developers to build, test, and run frontends like javasrc2cpg and jssrc2cpg via Bazel. The setup pins Bazel 9.1.0, configures Scala 3.8.3, and manages dependencies for AST generators and Maven artifacts, while documentation (bazel.md) clarifies that this is currently experimental and not used for CI or releases.

(repo-wide) · high confidence

Introduce ghidra2cpg frontend for binary analysis

Adds a new \ghidra2cpg\ frontend that converts binary executables into the Code Property Graph (CPG) using the Ghidra reverse-engineering framework. The implementation includes a main entry point (\Main.scala\) and the core frontend logic (\Ghidra2Cpg.scala\), which initializes a headless Ghidra environment, loads the input binary, and runs architecture-specific passes for MIPS, ARM, and x86 to extract functions, control flow, and types. It also integrates standard passes for metadata, namespaces, jumps, and literals, while silencing Ghidra's verbose console output to reduce noise.

joern-cli/frontends/ghidra2cpg/src/main/scala/io/joern/ghidra2cpg · high confidence

Introduce jimple2cpg frontend for Java CPG generation

Adds the jimple2cpg frontend, enabling users to generate Code Property Graphs (CPG) from Java class files, JARs, and Android APK/DEX files. The tool leverages the Soot framework to parse bytecode and construct the AST, supporting recursive JAR unpacking with configurable depth, optional decompilation of class files to Java source, and specific handling for Android applications (including dynamic package/directory marking). It also generates metadata, type nodes, declaration reference edges, and config files as part of the standard x2cpg pipeline. Also in this area: New AST creation pass for Jimple frontend.

jimple2cpg · high confidence

Introduce jimple2cpg frontend for Soot's Jimple IR

Adds the jimple2cpg frontend, formerly known as Plume, which converts Soot's Jimple IR into a Code Property Graph (CPG). This change introduces the necessary build artifacts, shell scripts (jimple2cpg.sh), and documentation (README.md) to allow users to generate CPGs from Jimple-based Java code and import them into Joern.

joern-cli/frontends/jimple2cpg · high confidence

Introduce query database and macro infrastructure for Joern

The macros module now provides the core infrastructure for defining, discovering, and executing code queries. It introduces a \QueryDatabase\ that automatically scans classpaths for query bundles (classes implementing \QueryBundle\) and instantiates queries using reflection, supporting default argument injection for parameters. A new Scala 3 macro, \withStrRep\, allows query authors to capture the source code of traversal lambdas as string representations, which are stored alongside the executable traversal logic in the \Query\ case class. This enables the console to display the original query code alongside its results.

macros · high confidence

Introduce scan pass and finding output utilities

Adds a new ScanPass component in the console module that executes security queries against the Code Property Graph (CPG) and collects findings. To prevent undefined behavior caused by nested parallelism with the data-flow engine, the pass runs sequentially using CpgPass rather than a parallel variant. The change also includes helper utilities to format and print human-readable scan results to standard output, including sorting by score and displaying evidence locations.

console/src/main/scala/io/joern/console/scan · high confidence

Introduce structured workspace and project management components

The console now uses new \Project\, \Workspace\, \WorkspaceLoader\, and \WorkspaceManager\ classes to manage code analysis projects. \Project\ tracks the state of individual codebases (including loaded CPGs and applied overlays), while \Workspace\ provides a unified view of all projects and renders them in a formatted table. \WorkspaceManager\ handles the lifecycle of these projects, including creating directories, persisting metadata in \project.json\, and managing the underlying file system structure for CPG storage and overlays.

console/src/main/scala/io/joern/console/workspacehandling · high confidence

Introduces Kotlin compiler environment builder with assertion-error resilience

Adds a new \CompilerAPI\ component in the Kotlin frontend that constructs the \KotlinCoreEnvironment\ for analysis. This implementation configures content roots, Java source roots, and JDK home, while specifically handling resource-based dependencies by copying them to temporary files to satisfy JVM classpath requirements. It also integrates a custom logger factory that suppresses \AssertionError\ exceptions from the underlying Kotlin compiler's default logger, allowing the analysis to continue on a best-effort basis rather than failing on internal compiler errors.

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/compiler · high confidence

Introduction of OSS Data Flow Engine with Data Dependence Graph Visualization

The dataflowengineoss module now provides a complete, standalone data flow analysis engine. It introduces a new ANTLR grammar for defining flow semantics and a DefaultSemantics object that configures taint tracking for common C and Java operators and library functions. The engine computes reaching definitions to build a Data Dependence Graph (DDG), which is now visualizable via new layer creators that dump DDG, Program Dependence Graph (PDG), and full CPG dot files. Additionally, the language API is extended with implicit conversions for traversing data flows (ddgIn, reachableBy) and rendering path results in tables.

dataflowengineoss/src/main · high confidence

Introduction of the semanticcpg module with access path analysis and graph visualization

This change introduces the \semanticcpg\ module, establishing a new location for core semantic analysis capabilities. It adds a comprehensive access path algebra system (\AccessPath\, \AccessElement\, \TrackedBase\) to model and track memory references, including support for pointer shifts, indirection, and address-of operations. Additionally, it provides a suite of DOT graph generators (\AstGenerator\, \CallGraphGenerator\, \CfgGenerator\, \TypeHierarchyGenerator\) for visualizing code structure, control flow, and type hierarchies, alongside a \CodeDumper\ for source code extraction and highlighting.

semanticcpg · high confidence

JavaScript/TypeScript frontend introduces AST generation runner and package dependency parser

The jssrc2cpg frontend now includes a dedicated AstGenRunner utility to manage the external astgen binary, handling environment variable configuration (ASTGEN\_BIN), file filtering (excluding minified, transpiled, test, and config files), and graceful error handling during parsing. Additionally, a new PackageJsonParser utility has been added to extract project dependencies from package.json and package-lock.json files, supporting caching for performance. These changes enhance the robustness and configurability of the JavaScript/TypeScript source-to-CPG conversion process.

joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/utils · high confidence

JavaSrc2cpg frontend now supports Bazel builds

The JavaSrc2cpg frontend now includes a Bazel build configuration (BUILD file), allowing users to build and test the component using Bazel in addition to the existing sbt workflow. This change introduces Bazel rules for the main library, tests, and binary distribution, integrating the frontend into the project's Bazel workspace.

joern-cli/frontends/javasrc2cpg · high confidence

Kotlin2CPG now fetches and downloads dependencies via an external jar4import service

The Kotlin2CPG frontend now integrates with an external jar4import service to resolve and download JAR dependencies. When a service URL is provided, the tool validates the connection via a health check, queries the service for dependency coordinates based on import names, and automatically downloads the corresponding artifacts using Maven's ArtifactResolver. This shifts dependency resolution from local classpath scanning to a remote service, enabling more robust handling of transitive dependencies during code property graph generation.

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/jar4import · high confidence

New C code analysis scripts for memory safety and const correctness

Added a new set of built-in analysis scripts for C code in the Joern CLI, including detection of malloc memory leaks, potential integer overflows in malloc size arguments, assignments of pointer arithmetic results to integers, and accesses to userspace memory addresses. The release also introduces scripts to identify functions that may be marked as const and to detect assignments to const parameters or struct members, alongside a comprehensive list of Linux syscalls. These scripts are registered in the new scripts.json manifest for easy discovery.

joern-cli/src/main/resources/scripts/c · high confidence

New CLI commands for code slicing, flow analysis, and vector embeddings

The \joern-cli\ module now includes dedicated commands for advanced code analysis: \joern-slice\ extracts data-flow or usage slices from a CPG with configurable filters (e.g., method names, annotations, operator exclusion) and parallelism; \joern-flow\ traces data flows between source and sink parameters with configurable depth and verbose output; and \joern-vectors\ generates vector embeddings of code nodes and methods using feature hashing, with an option to map dimensions back to features. These commands rely on the new \CpgBasedTool\ and \DefaultOverlays\ utilities to automatically apply default and data-flow overlays when missing, ensuring consistent analysis across all new tools.

joern-cli/src/main/scala/io/joern/joerncli · high confidence

New JavaParser AST printer utility for debugging

Added a new \JavaParserAstPrinter\ utility in the \javasrc2cpg\ frontend that allows users to print the raw JavaParser AST (in YAML format) for source files. This tool aids in debugging and understanding the internal parsing state by iterating through input files, parsing them via \SourceParser\, and outputting the resulting AST nodes.

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/jpastprinter · high confidence

New Kotlin2CPG passes for config, dependencies, and type recovery

The Kotlin frontend now includes dedicated passes to enhance the generated Code Property Graph. A new ConfigPass adds configuration files as CPG nodes, while DependenciesFromMavenCoordinatesPass parses Maven coordinates to create explicit dependency nodes. Additionally, KotlinTypeRecoveryPassGenerator and its associated components provide Kotlin-specific type inference logic, and KotlinTypeHintCallLinker filters call nodes to improve type hint resolution.

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/passes · high confidence

New gadget analysis script for binary analysis

A new script named gadgets.sc has been added to the binary analysis resources. This script allows users to identify potential return-oriented programming (ROP) gadgets by extracting the five instructions preceding each return node in the control flow graph and saving the results to /tmp/gadgets.txt.

joern-cli/src/main/resources/scripts/binary · high confidence

New linter rules for code style and iteration safety

The linter-rules module now includes three new scalafix rules: UnorderedIteration flags order-sensitive operations (such as foreach, map, or toList) on non-deterministic collections like HashMap or HashSet to prevent inconsistent analysis results; RestrictedImports warns against using BetterFiles and scala.sys.process in favor of internal utilities; and SingleLetterIdentifiers flags variable and parameter names that are too short to improve readability.

linter-rules · high confidence

New utility functions for Kotlin PSI object and destructuring handling

The Kotlin frontend now includes a new \PsiUtils\ object that provides helper methods for working with Kotlin PSI elements. Specifically, it adds \nonUnderscoreDestructuringEntries\ to filter out underscore placeholders from destructuring declarations, and \objectIdxMaybe\ to calculate the index of an object declaration within its containing scope by traversing the tree. These utilities support more accurate parsing and indexing of Kotlin object expressions and destructuring patterns.

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/psi · high confidence

PHP frontend introduces dedicated scope management and dependency downloading utilities

The PHP frontend now includes new utility classes to improve code analysis accuracy and project setup. A new \Scope\ and \ScopeElement\ implementation provides robust handling of namespaces, types, and methods, ensuring unique naming for anonymous classes, temporary variables, and closures to prevent duplicates. Additionally, a \DependencyDownloader\ utility automatically fetches and extracts PHP dependencies from Packagist, placing them in a temporary directory for parsing, while an \ArrayIndexTracker\ supports precise tracking of array access patterns.

joern-cli/frontends/php2cpg/src/main/scala/io/joern/php2cpg/utils · high confidence

Python parser now supports pattern matching syntax

The Python parser in the pysrc2cpg frontend has been updated to recognize and parse Python 3.10+ pattern matching constructs (the \match\/\case\ statement). This change introduces new AST nodes for match statements, match cases, and various match guards (such as \MatchValue\, \MatchSingleton\, \MatchSequence\, \MatchMapping\, \MatchClass\, \MatchStar\, \MatchAs\, and \MatchOr\), allowing static analysis tools to correctly model code using structural pattern matching.

joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pythonparser · high confidence

Ruby frontend adds configuration file parsing and dependency resolution passes

The Ruby source-to-CPG frontend now includes dedicated passes to parse configuration files and resolve project dependencies. The new ConfigFileCreationPass identifies and processes Gemfiles, Gemfile.lock, YAML, XML, and ERB files to populate the configuration layer. Additionally, the DependencyPass parses Gemfile and Gemfile.lock contents to extract gem names, versions, and source URLs, creating corresponding dependency nodes in the graph. These changes enable better tracking of project structure and external library usage within the analyzed Ruby codebase.

joern-cli/frontends/rubysrc2cpg/src/main/scala/io/joern/rubysrc2cpg/passes · high confidence

Swift source-to-CPG frontend initial implementation

The swiftsrc2cpg frontend is introduced, enabling the conversion of Swift source code into the Code Property Graph. This implementation parses Swift ASTs generated by swiftastgen and constructs CPG nodes for a wide range of Swift constructs, including classes, extensions, closures, guard statements, defer statements, optional binding, tuple patterns, and array/dictionary initializers. It features a custom scope manager to handle Swift-specific scoping rules (such as extensions and static contexts) and cleans type names by stripping generic parameters while preserving semantic tags. The pass runs in parallel using ForkJoinParallelCpgPassWithAccceptor to process files efficiently.

swiftsrc2cpg · high confidence

gosrc2cpg frontend initialization with configurable goastgen version and logging

The gosrc2cpg frontend now includes its own configuration and logging setup. Users can now specify the version of the underlying goastgen tool via the \gosrc2cpg.goastgen\_version\ setting in \application.conf\ (defaulting to 0.1.2). Additionally, logging is configured via \log4j2.xml\ to output colored console logs, with the log level controllable via the \SL\_LOGGING\_LEVEL\ environment variable.

joern-cli/frontends/gosrc2cpg/src/main/resources · high confidence

gosrc2cpg: Initial support for Go lambda expressions and improved package namespace handling

The gosrc2cpg frontend now supports parsing Go lambda (closure) expressions, generating corresponding AST nodes for the lambda function and its enclosing type declaration, while excluding them when processing dependency code. It also introduces a caching mechanism to handle cases where a Go package name differs from its enclosing folder name, ensuring correct fully qualified namespace generation. Additionally, the frontend now tracks used dependencies from go.mod to optimize processing by ignoring indirect dependencies and unused packages.

gosrc2cpg · high confidence

Architecture

Kotlin AST creation logic refactored into modular traits

The Kotlin frontend's AST generation has been restructured by extracting specific creation logic into dedicated traits: \AstForDeclarationsCreator\ (handling classes, objects, and constructors), \AstForPrimitivesCreator\ (handling literals, string templates, and name references), \AstForStatementsCreator\ (handling control flow like for-loops with destructuring), \BindingContextUtils\ (providing access to Kotlin compiler binding context), and \KotlinAstVisitorHelpers\ (providing utility methods for AST traversal). This modularization improves code organization and maintainability of the Kotlin-to-CPG translation process.

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/ast · high confidence

Refactor AST creation for declarations into separate modules

The logic for creating AST nodes for method, lambda, and type declarations has been extracted from the main AstCreator into dedicated components within the declarations package. This includes the new AstForDeclarationsCreator trait, which composes specific creators for types and methods, and the BinarySignatureCalculator, which handles the generation of binary signatures for various Java declarations (classes, enums, records, etc.) using ASM. This change restructures the internal codebase to improve modularity without altering the external behavior of the Java source-to-CPG conversion.

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/astcreation/declarations · high confidence

Refactor Java source AST creation into modular expression handlers

The Java source frontend's AST creation logic has been restructured by extracting expression handling into dedicated, composable traits (AstForExpressionsCreator, AstForNameExpressionsCreator, AstForPatternExpressionsCreator, AstForSimpleExpressionsCreator, and AstForVarDeclAndAssignsCreator). This modularization centralizes the dispatch for Java expressions—such as binary operations, array access, variable declarations, and pattern matching—into specialized modules, improving code organization and maintainability without altering the external analysis capabilities.

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/astcreation/expressions · high confidence

Refactored javasrc2cpg AST creation into focused, modular traits

The \javasrc2cpg\ frontend has been restructured to improve maintainability and separation of concerns. The monolithic \AstCreator\ class has been decomposed into focused internal traits: \AstForDeclarationsCreator\, \AstForExpressionsCreator\, \AstForStatementsCreator\, and \AstForLambdasCreator\. This change moves the creation logic for methods, type declarations, expressions, and statements into their respective modules, while the main \AstCreator\ now orchestrates these components. Additionally, a new \TokenParser\ and \Model\ have been introduced in the \jartypereader\ package to handle Java type signature descriptors, supporting more precise type resolution.

javasrc2cpg · high confidence

Ruby AST creation refactored into focused internal traits

The \AstCreator\ class in the Ruby source-to-CPG frontend has been decomposed from a single monolithic implementation into a set of focused internal traits (\AstCreatorHelper\, \AstForStatementsCreator\, \AstForExpressionsCreator\, \AstForControlStructuresCreator\, \AstForFunctionsCreator\, and \AstForTypesCreator\). This structural change organizes the AST generation logic by Ruby language construct (e.g., separating control structures, expressions, functions, and types), improving code maintainability and separation of concerns within the \rubysrc2cpg\ module.

joern-cli/frontends/rubysrc2cpg/src/main/scala/io/joern/rubysrc2cpg/astcreation · high confidence

Behavioural changes

31 commits (2 fixes) modifying joern-cli/frontends/csharpsrc2cpg/src/main/scala/io/joern/csharpsrc2cpg

A change to existing behaviour in joern-cli/frontends/csharpsrc2cpg/src/main/scala/io/joern/csharpsrc2cpg — 31 commits (2 fixs), 2 files: “\[c\#\] Implement AST Generation with DotNetAstGen (\#3882)”; “\[c\#\] Download & Summarise Dependencies (\#4293)”; “\[c\#\] fix top-level main's signature (\#5279)”; and 28 more (refs \#3882, \#4293, \#5279, \#4196, \#4326, …).

joern-cli/frontends/csharpsrc2cpg/src/main/scala/io/joern/csharpsrc2cpg · medium confidence · unverified

33 commits (1 fix) modifying joern-cli/frontends/c2cpg/src/main/scala/io/joern/c2cpg

A change to existing behaviour in joern-cli/frontends/c2cpg/src/main/scala/io/joern/c2cpg — 33 commits (1 fix), 1 file: “\[c2cpg\] Make method fullNames truly unique (\#5346)”; “\[x2cpg\] Added server mode (\#4892)”; “Refactorings and clean-ups for c2cpg (\#688)”; and 30 more (refs \#5346, \#4892, \#688, \#1060, \#5396, …).

joern-cli/frontends/c2cpg/src/main/scala/io/joern/c2cpg · medium confidence · unverified

35 commits (4 fixes) modifying joern-cli/frontends/php2cpg/src/main/scala/io/joern/php2cpg

A change to existing behaviour in joern-cli/frontends/php2cpg/src/main/scala/io/joern/php2cpg — 35 commits (4 fixs), 1 file: “\[php\] Use Robust Version Checking (\#5324)”; “Add php2cpg implementation for basic testcase (\#1709)”; “refactor and fix ExternalCommand (\#5548)”; and 32 more (refs \#5324, \#1709, \#5548, \#2919, \#3886, …).

joern-cli/frontends/php2cpg/src/main/scala/io/joern/php2cpg · medium confidence · unverified

42 commits (6 fixes) modifying joern-cli/frontends/jimple2cpg/src/main/scala/io/joern/jimple2cpg

A change to existing behaviour in joern-cli/frontends/jimple2cpg/src/main/scala/io/joern/jimple2cpg — 42 commits (6 fixs), 1 file: “\[jimple2cpg\] Do not unpack "jars in jars" by default (\#3170)”; “\[x2cpg\] Use SourceFiles.filterFile logic to also filter config files (\#5641)”; “Allow only a single input path for CPG generation (\#1521)”; and 39 more (refs \#3170, \#5641, \#1521, \#3898, \#1060, …).

joern-cli/frontends/jimple2cpg/src/main/scala/io/joern/jimple2cpg · medium confidence · unverified

52 commits (8 fixes) modifying joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg

A change to existing behaviour in joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg — 52 commits (8 fixs), 1 file: “pysrc2cpg: File & Config Reading Consistency (\#2869)”; “Run delombok by default when a lombok dependency is detected (\#1716)”; “Use \ConcurrentWriterCpgPass\ in most frontends (\#1086)”; and 49 more (refs \#2869, \#1716, \#1086, \#5641, \#3886, …).

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg · medium confidence · unverified

Added x86-specific control flow and return edge passes

The ghidra2cpg frontend now includes two new passes for x86 binaries: ReturnEdgesPass and X86FunctionPass. ReturnEdgesPass identifies return values by detecting calls where the RAX/EAX register is used as an argument, creating REACHING\_DEF edges to model data flow. X86FunctionPass handles the structural decomposition of x86 functions, explicitly managing control flow graph (CFG) edges while skipping connections after unconditional jumps (JMP) to preserve correct execution paths. These changes improve the accuracy of the control flow and data flow graphs generated for x86 architectures.

joern-cli/frontends/ghidra2cpg/src/main/scala/io/joern/ghidra2cpg/passes/x86 · high confidence

Build infrastructure consolidated and upgraded to sbt 1.12.5

The project's build system has been restructured into a single consolidated \project\ directory, replacing the previous multi-module meta-build setup. This change upgrades the build tool to sbt 1.12.5 and updates sbt-native-packager to 1.11.1. A new \Versions.scala\ file centralizes dependency management, and helper utilities like \DownloadHelper\ and \UrlRetry\ have been introduced to improve download reliability with retry logic. The build now explicitly requires JDK 13+ and defines a comprehensive list of subprojects, including frontends like \javasrc2cpg\, \ghidra2cpg\, and \x2cpg\.

project · high confidence

C\# frontend adds configuration and colorful logging

The C\# source-to-CPG frontend now includes an application configuration file that sets the dotnetastgen tool version to 0.43.0, alongside a new log4j2 configuration that enables colored console output for improved readability.

joern-cli/frontends/csharpsrc2cpg/src/main/resources · high confidence

Console architecture refactored into modular components with server-mode output capture

The console module has been restructured into a set of focused components: BridgeBase now handles CLI argument parsing and configuration, Console manages the interactive workspace and project lifecycle, and PluginManager handles plugin installation and removal. A new Commit component allows users to apply pending graph changes, while Run dynamically generates analyzer commands based on available LayerCreators. Additionally, server-mode users will now see captured output from the REPL session, as GlobalReporting now aggregates reported strings for retrieval outside the REPL context.

console/src/main/scala/io/joern/console · high confidence

Eclipse CDT core integration now uses a custom, OSGI-free logging plugin

The C2CPG frontend now bundles a stripped-down version of the Eclipse CDT core library (version 9.2.100) to run without the full Eclipse OSGI runtime. A new \CCorePlugin.java\ replaces the original Eclipse class to provide a simplified logging mechanism backed by SLF4J, preventing initialization exceptions in parser components that rely on this plugin. The release process has been updated to download the official CDT JAR, exclude its original signature and plugin class, inject the custom implementation, and publish the resulting artifact to Sonatype Central for use by Joern.

joern-cli/frontends/c2cpg/eclipse-cdt · high confidence

Enforce unique fullNames for methods, type declarations, and namespace blocks in C/C++ CPGs

The C2C++ frontend now includes a new FullNameUniquenessPass that runs after AST creation to resolve duplicate fullNames for methods, type declarations, and namespace blocks. In C and C++ code, identical fullNames can arise from static functions in different files, classes split across headers and implementations, or unresolved types. This pass identifies such duplicates and appends unique suffixes to ensure every node has a distinct fullName, which is required for correct linking and querying. It also updates affected call sites and bindings to reflect the new fullNames, preventing linking errors. Additionally, a TypeDeclNodePass ensures that types missing type declarations are stubbed with unique fullNames, and a PreprocessorPass handles source file discovery and preprocessor statement extraction.

joern-cli/frontends/c2cpg/src/main/scala/io/joern/c2cpg/passes · high confidence

Enhanced C\# scope management and type resolution

The C\# frontend now uses a new CSharpScope implementation to improve how it resolves types and methods. This change allows fully-qualified type names (e.g., System.Console) to be resolved even without explicit imports, provided there is a unique match in the global type summary. It also introduces more flexible matching for extension methods and adds support for resolving getter and setter method invocations from field accesses.

joern-cli/frontends/csharpsrc2cpg/src/main/scala/io/joern/csharpsrc2cpg/datastructures · high confidence

Ghidra2cpg migration to ForkJoinParallelCpgPass

The Ghidra frontend's analysis passes (FunctionPass, JumpPass, LiteralPass, MetaDataPass, NamespacePass, and PCodePass) have been refactored to extend ForkJoinParallelCpgPass instead of the previous SimpleCpgPass base class. This change updates the internal execution model to use parallel processing for analyzing functions and other code elements, which should improve performance and scalability when decompiling binaries into the Code Property Graph.

joern-cli/frontends/ghidra2cpg/src/main/scala/io/joern/ghidra2cpg/passes · high confidence

Improved AST creation and declaration reference handling in Jimple frontend

The Jimple frontend now uses a new AstCreator pattern for AST generation, replacing the previous implementation to better handle try-catch control flow and validate the AST early. Additionally, a new DeclarationRefPass has been introduced to explicitly link declaration nodes to their corresponding identifier nodes via REF edges, ensuring more accurate symbol resolution in the resulting code property graph.

joern-cli/frontends/jimple2cpg/src/main/scala/io/joern/jimple2cpg/passes · high confidence

Improved C/C++ parsing reliability and logging in c2cpg

The c2cpg parser now better handles MSVC-specific syntax by defining integer types (like \_\_int64) and calling conventions, ensuring correct parsing of code using these dialects. It also introduces a custom file content provider that intelligently resolves header file inclusions by searching the codebase and selecting the closest match, while supporting preprocessed files (.i) and additional C++ extensions (e.g., .cxx). Additionally, parse problems and preprocessor statements are now logged with detailed context, aiding in debugging complex translation units.

joern-cli/frontends/c2cpg/src/main/scala/io/joern/c2cpg/parser · high confidence

Improved type resolution for modular JDKs and non-standard archives

The Java source frontend now resolves types more reliably in complex environments. It introduces \BytecodeIndexedClassPath\ to handle fat JARs, repackaged JARs, and JMODs by reading the actual package declaration from bytecode rather than relying on file paths. It also adds \JrtRuntimeImageClassPath\ to support JDK modular runtime images (JEP 220), ensuring type information is available even when only a minimal \jlink\ image is present. Additionally, an \EagerSourceTypeSolver\ preloads type information from source files to speed up resolution, while \TypeSizeReducer\ removes method bodies from parsed types to reduce memory usage.

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/typesolvers · high confidence

Introduce configurable astgen version and colored logging for jssrc2cpg

The jssrc2cpg frontend now uses astgen version 3.50.1, as defined in the new application.conf configuration file, and provides colored console logging via a new log4j2.xml configuration that highlights log levels.

joern-cli/frontends/jssrc2cpg/src/main/resources · high confidence

Introduces RubyScope for improved variable capture and type resolution

The \rubysrc2cpg\ frontend now uses a new \RubyScope\ data structure to manage lexical scoping, which improves the accuracy of variable capture detection and type resolution. This change ensures that captured variables are correctly identified across method boundaries and that built-in methods for types like \Array\ and \Hash\ are properly resolved in scope, leading to more precise code property graphs for Ruby source code.

joern-cli/frontends/rubysrc2cpg/src/main/scala/io/joern/rubysrc2cpg/datastructures · high confidence

New AST creation architecture for Jimple2CPG

The Jimple2CPG frontend now uses a new AstCreator pattern that splits AST generation into dedicated traits for declarations, expressions, and statements. This refactoring improves how the tool translates Jimple bytecode into the Code Property Graph, specifically enhancing control-flow handling and error resilience during decompilation. Users benefit from more accurate AST nodes for binary/unary expressions, method invocations, and object allocations, with better support for try-catch blocks and unhandled Soot types.

joern-cli/frontends/jimple2cpg/src/main/scala/io/joern/jimple2cpg/astcreation · high confidence

New AlmaLinux-based Docker images for Joern

The CI pipeline now provides new container images based on AlmaLinux 9 and 8, replacing previous base images. These include standard images (Dockerfile.alma, Dockerfile.alma8) and a new slim variant (Dockerfile.slim) that reduces OS packages and excludes plugins to minimize size. The images use Java 17, set JOERN\_HOME to /opt/joern/joern-cli, and default to running the joern command via CMD.

ci · high confidence

New CPG generator architecture and expanded language support

The console now uses a new \CpgGenerator\ interface and factory to manage language frontends, replacing the previous implementation. This change introduces dedicated generator classes for ABAP, C/C++, C\# (both commercial and OSS), Go, Java (commercial and OSS), JavaScript, Kotlin, LLVM, PHP, Python, Ruby, Rust, and Swift. The \ImportCode\ API has been updated to expose these as \importCode.\<language\>\ methods (e.g., \importCode.abap\, \importCode.csharpsrc\), and the system now automatically detects the language based on file extensions or directory contents. Several frontends (Java, C\#, Go) now support both commercial and open-source variants, falling back to the OSS version if the commercial one is unavailable. Post-processing passes for type recovery are now automatically applied for source-based frontends like Java, JavaScript, Python, PHP, Ruby, and Swift.

console/src/main/scala/io/joern/console/cpgcreation · high confidence

New Ruby parser implementation based on JSON AST

The Ruby source-to-code-property-graph frontend now uses a new parser implementation that relies on a JSON-based Abstract Syntax Tree. This change introduces new Scala classes in the parser package (RubyJsonAst, RubyJsonParser, RubyJsonToNodeCreator) to handle the deserialization of Ruby code structures, including support for new Ruby features like array pattern matching, ERB files, and improved handling of access modifiers and regex variables.

joern-cli/frontends/rubysrc2cpg/src/main/scala/io/joern/rubysrc2cpg/parser · high confidence

New source file filtering logic for Kotlin CPG generation

The Kotlin frontend now uses a dedicated \SourceFilesPicker\ component to determine which files are included in the Code Property Graph. This logic explicitly filters out test directories (such as \src/test\, \androidTest\, \jvmTest\), build artifacts (\target\, \build\), and Android layout XMLs, while ensuring that configuration files like \build.gradle\, \build.gradle.kts\, and \.kts\ scripts are preserved and processed.

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/files · high confidence

PHP frontend adds internal parser, builtin function list, and configuration resources

The PHP frontend now ships with a bundled ClassParser.php script to parse PHP symbol information, a comprehensive builtin\_functions.txt list for recognizing PHP built-in functions, a php.ini configuration to set memory\_limit to -1 (preventing out-of-memory errors on large files), and a log4j2.xml configuration for colored console logging. These resources support the frontend's static analysis capabilities by providing local parsing logic, function metadata, and stable runtime behavior.

joern-cli/frontends/php2cpg/src/main/resources · high confidence

PHP frontend refactored into parallel passes with duplicate fullName resolution

The PHP frontend's code analysis pipeline has been restructured into distinct, parallel processing passes. AstParsingPass now groups PHP files into batches of 20 to optimize parser startup performance, while AstCreationPass handles AST generation using relative filenames. A new DependencySymbolsPass parses external dependency classes to include their type declarations in the CPG. Crucially, FullNameUniquenessPass resolves naming collisions that occur when the same class or function name is defined in multiple files by appending unique suffixes and updating corresponding call sites, ensuring all fullNames in the graph are unique for reliable querying.

joern-cli/frontends/php2cpg/src/main/scala/io/joern/php2cpg/passes · high confidence

Refactor Jimple2CPG declaration handling into dedicated traits

The Jimple-to-CPG frontend now organizes AST creation for declarations into three new, focused traits: \AstForDeclarationsCreator\, \AstForMethodsCreator\, and \AstForTypeDeclsCreator\. This refactoring consolidates the logic for generating AST nodes for classes, methods, and fields, ensuring that modifiers, annotations, and inheritance information are correctly attached to the corresponding nodes in the Code Property Graph.

joern-cli/frontends/jimple2cpg/src/main/scala/io/joern/jimple2cpg/astcreation/declarations · high confidence

Refactor ghidra2cpg utils and silence Ghidra decompiler noise

The ghidra2cpg utility layer has been restructured into dedicated modules: CommandLineConfig provides static CLI arguments, Decompiler wraps the Ghidra DecompInterface with caching, PCodeMapper handles P-code to CPG node translation, Utils contains helper methods for creating CPG nodes, and WarnAndUpErrorLogger suppresses verbose Ghidra progress messages by demoting info and decompiler warnings to debug level, resulting in cleaner console output.

joern-cli/frontends/ghidra2cpg/src/main/scala/io/joern/ghidra2cpg/utils · high confidence

Refactor memory operation tracking in Python source-to-CPG conversion

The \pysrc2cpg\ module now uses a new \MemoryOperationCalculator\ to track variable memory operations (Store, Load, Del) during AST traversal, replacing the previous implementation. This change introduces a dedicated \AstNodeToMemoryOperationMap\ for identity-based caching and a \ScopeNameCollection\ to manage identifier names within lexical scopes, ensuring more accurate tracking of variable usage and scope resolution in the generated CPG.

joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/memop · high confidence

Refactored Java source AST creation into modular statement handlers

The Java source-to-CPG frontend has reorganized its AST creation logic by extracting specific statement handlers into dedicated files, such as AstForForLoopsCreator and AstForStatementsCreator. This refactoring centralizes the handling of control structures (for-loops, foreach-loops, if/while/do statements) and introduces support for local record declarations. Users benefit from a more maintainable codebase that correctly scopes pattern-matching variables within these control structures and ensures local records are properly represented in the generated code property graph.

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/astcreation/statements · high confidence

Refactored Java source frontend utility layer with new binding and capture logic

The \javasrc2cpg\ utility package has been restructured to improve how the frontend handles method bindings, variable captures, and Lombok processing. A new \BindingTable\ and \BindingTableAdapter\ system now manages method binding resolution, correctly handling generic type parameter overrides and inner class captures. Variable capture detection is now performed by a dedicated \CaptureUseFinder\ that accurately tracks undeclared variables across complex scopes like lambdas, switch expressions, and try-with-resources. Additionally, the \Delombok\ utility has been enhanced to automatically detect Lombok usage by scanning source code, run delombok in parallel, and filter stderr output to prevent silent errors, while \PackageRootFinder\ and \SourceParser\ now provide more robust handling of package structures and Java 25 language level support.

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/util · high confidence

Refactored Jimple statement AST creation into a dedicated trait

The logic for converting Jimple statements into Abstract Syntax Tree (AST) nodes has been extracted from the main AstCreator into a new \AstForStatementsCreator\ trait. This change centralizes the handling of specific statement types—including assignments, returns, switches, throws, and monitors—within the \jimple2cpg\ frontend, improving code organization and separation of concerns without altering the resulting code property graph output.

joern-cli/frontends/jimple2cpg/src/main/scala/io/joern/jimple2cpg/astcreation/statements · high confidence

Replaced legacy REPL with new JoernConsole and ReplBridge

The Joern CLI console has been refactored to use a new \JoernConsole\ implementation and \ReplBridge\ entry point, replacing the previous REPL infrastructure. This change introduces a structured \JoernProject\ model for workspace handling, integrates the OssDataFlow layer by default via \applyDefaultOverlays\, and configures the interactive shell with specific pre-execution imports and commands (such as \ossDataFlowOptions\) defined in \RunBeforeCode\. Users will now interact with a console that explicitly manages data flow semantics and provides a standardized banner and prompt, while the underlying architecture for script execution and shell initialization has been reorganized into these new components.

joern-cli/src/main/scala/io/joern/joerncli/console · high confidence

Ruby frontend configuration and logging setup

The Ruby source-to-CPG frontend now includes explicit configuration for the \ruby\_ast\_gen\ version (0.59.7) and Joern type stubs version (0.6.0) via \application.conf\. Additionally, a \log4j2.xml\ file is introduced to provide colored console logging, enhancing visibility into the parsing process for users.

joern-cli/frontends/rubysrc2cpg/src/main/resources · high confidence

Ruby frontend switches to a full intermediate AST representation

The \rubysrc2cpg\ frontend now uses a dedicated intermediate AST layer (defined in \RubyIntermediateAst.scala\) to represent Ruby constructs before lowering them to the Code Property Graph. This change introduces specific data structures for Ruby expressions, statements, type declarations (classes, modules, singleton classes), and method declarations, along with a new scope management system (\ScopeElement.scala\) and a \RubyProgramSummary\ for handling type stubs. This architectural shift allows the frontend to handle complex Ruby features—such as multi-assignment, block parameters, and access modifiers—more robustly by decoupling the parsing of the Ruby AST (from \ruby\_ast\_gen\) from the CPG generation logic.

rubysrc2cpg · high confidence

Ruby source-to-CPG frontend introduces parallel AST generation and type recovery

The \rubysrc2cpg\ frontend now processes Ruby source files using a parallelized architecture: it delegates AST generation to a shared JRuby environment via \RubyAstGenRunner\, then concurrently constructs AST creators and computes program summaries before applying the main \AstCreationPass\. This change also enables built-in type recovery and type stubs by default, adds support for ERB files, and configures default file exclusions for common directories like \spec\, \tests\, \vendor\, and \db\.

joern-cli/frontends/rubysrc2cpg/src/main/scala/io/joern/rubysrc2cpg · high confidence

Schema extender rewritten with Scala DSL and FlatGraph

The schema extender tool has been reimplemented using a new Scala-based DSL and the FlatGraph code generation library. This change replaces the previous implementation, allowing users to extend the CPG schema by defining new node types and properties directly in Scala code, which is then processed by the FlatGraph DomainClassesGenerator to produce the updated schema artifacts.

joern-cli/src/universal/schema-extender/schema · high confidence

Shell wrappers added for c2cpg and jssrc2cpg binaries

Shell scripts (c2cpg.sh and jssrc2cpg.sh) have been added to the universal distribution directories for the C and JavaScript/TypeScript frontends. These wrappers resolve the script's absolute path to locate the corresponding binary and configuration files, ensuring the JVM runs with G1GC and a 128m compressed class space, and passes through any additional arguments provided by the user.

joern-cli/frontends/c2cpg/src/universal, joern-cli/frontends/jssrc2cpg/src/universal · high confidence

Simplified C\# frontend startup script with explicit logging configuration

The csharpsrc2cpg frontend now uses a simplified shell wrapper script that explicitly resolves the script's absolute directory to locate the log4j2 configuration file (log4j2.xml) and passes it to the underlying Java process. This ensures consistent logging behavior by directly specifying the configuration file path and disabling log4j lookup patterns for security, rather than relying on default classpath resolution.

joern-cli/frontends/csharpsrc2cpg · high confidence

Standardized launcher scripts for frontend tools

The shell launcher scripts for the C\#, Ghidra, Java, Jimple, and PHP frontends have been replaced with a unified template. These scripts now automatically resolve their absolute paths to locate the main executable and the log4j2 configuration file, ensuring consistent behavior across different operating systems (including macOS and Linux). Additionally, the launchers now explicitly configure the JVM to use the G1 garbage collector and set the compressed class space size to 128 MB, standardizing the runtime environment for these analysis tools.

(repo-wide) · high confidence

pysrc2cpg frontend rewritten to use x2cpg infrastructure with enhanced node properties and dependency tracking

The Python source-to-CPG frontend has been rewritten to leverage the x2cpg framework, introducing several behavioral changes for users. The frontend now automatically detects and includes configuration files such as requirements.txt, Pipfile, .toml, .ini, .yaml, .jinja2, and .html files. It parses requirements.txt to generate explicit DEPENDENCY nodes in the graph. Node properties have been enhanced: METHOD and TYPE\_DECL nodes now include end-line and end-column numbers, and TYPE\_DECL nodes set inheritsFromFullNames. The frontend also mangles names of redefined classes and functions to prevent collisions while preserving the last definition as the primary reference. Command-line options --ignore-paths and --ignore-dir-names allow users to exclude specific files or directories from analysis, and virtual environment directories are auto-detected and ignored by default.

joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg · high confidence

pysrc2cpg rewritten in Scala with new AST visitor and context management

The pysrc2cpg frontend has been rewritten in Scala, replacing the previous implementation. This change introduces a new \ContextStack\ for managing scope and variable references, a \PythonAstVisitor\ for traversing the Python AST, and a \Py2Cpg\ entry point that utilizes \DiffGraphBuilder\ and \DiffGraphApplier\ for CPG generation. The new architecture includes dedicated helper traits like \PythonAstVisitorHelpers\ for handling control structures and imports, and a custom AST definition in \io.joern.pythonparser.ast\ to align with CPython's structure while adding specific features like error statements and string expression lists.

pysrc2cpg · high confidence

x2cpg AST generation and scope management overhaul

The x2cpg module introduces a new \Ast\ data structure to centralize AST node and edge management, including automatic \order\ assignment and schema validation. The \AstGenRunner\ is refactored to correctly resolve external AST generation binaries, specifically fixing path resolution so that bare executable names are looked up on the system PATH rather than being incorrectly absolutized against the current working directory. A new \VariableScopeManager\ is added to handle variable scope stacks and reference resolution during CPG conversion. Additionally, language-specific import and type-resolution passes are implemented or updated: \PythonImportResolverPass\ and \DynamicTypeHintFullNamePass\ for Python, \ImplicitRequirePass\ for Ruby to handle autoloading, and \PhpTypeStubsParserPass\ for PHP builtin type signatures. Debugging capabilities are expanded with new layer creators to dump AST, CFG, and CDG graphs.

x2cpg · high confidence

Fixes

Fix orphan outer class references in constructor bodies

The Java source-to-CPG converter now correctly links outer class identifiers to their corresponding constructor parameters. Previously, when an outer class reference appeared in a constructor body but lacked an explicit reference edge, it was left orphaned; this new pass ensures these identifiers are properly connected, improving the accuracy of the control flow and data flow graphs for nested classes.

joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/passes · high confidence

Test coverage

1 commit adding/updating tests in dataflowengineoss/src/test/scala/io/joern/dataflowengineoss/language; 2 commits adding/updating tests in joern-cli/frontends/c2cpg/src/test/scala/io/joern/dataflowengineoss; 3 commits adding/updating tests in dataflowengineoss/src/test/scala/io/joern/dataflowengineoss/passes; Add PHP test fixture for CPG generation and validation; Added AST test coverage for Rust2Cpg; Added C\# test fixtures for code-to-CPG conversion and data-flow analysis; Added C++ test code for const-correctness scenarios; Added C2Cpg test fixtures and suites; Added Go code-to-CPG test fixtures; Added HTTP server integration tests for pysrc2cpg; Added MIPS-specific test coverage for call arguments and data flow; Added SlimAndroid test fixture for minimal Android app analysis; Added comprehensive parser tests for Python statements; Added comprehensive test coverage for C2Cpg AST creation; Added concurrency tests for the Types registry; Added config tests for multiple frontends; Added dataflow and reaching-definition tests for C code analysis; Added dataflow test suite for Kotlin2CPG; Added dataflow test suite for Python source-to-CPG conversion; Added dataflow tests for Go source-to-CPG conversion; Added dataflow tests for Jimple2CPG querying; Added dataflow tests for Ruby source frontend; Added integration tests for the console script runner; Added query tests for C2CPG AST, control flow, and data flow; Added query tests for Ruby frontend parsing and AST modeling; Added test binaries and coverage script for Ghidra frontend; Added test case for detecting unfreed malloc calls; Added test code for free() usage in linked list; Added test code for malloc overflow detection; Added test code for syscalls and user-space memory access; Added test code for unsafe pointer subtraction scenarios; Added test configuration files for jimple2cpg; Added test coverage for C2C++ type system passes; Added test coverage for C2CPG parsing and metadata passes; Added test coverage for Joern CLI scripting, parsing, and export features; Added test coverage for Kotlin CPG querying capabilities; Added test coverage for console configuration, language detection, and workspace management; Added test coverage for javasrc2cpg querying capabilities; Added test coverage for javasrc2cpg querying capabilities; Added test coverage for jssrc2cpg frontend; Added test fixtures and scripts for multiple frontends and features; Added test fixtures for Android app and Kotlin compiler plugins; Added test fixtures for Ghidra binary-to-CPG conversion; Added test fixtures for Jimple data flow analysis; Added test resources for JavaSrc2CPG config file detection; Added tests for ARM binary CPG querying; Added tests for C macro expansion and handling; Added tests for C\# AST node creation; Added tests for C\# dependency resolution and metadata generation; Added tests for C\# frontend IO capabilities; Added tests for C++17 language features; Added tests for C++20 feature parsing support; Added tests for C2C PG DOT graph generators; Added tests for C2C control-flow graph creation; Added tests for C2Cpg IO capabilities; Added tests for CDT macro expansion and header file resolution logic; Added tests for FullNameSemanticsParser; Added tests for Go module namespace resolution; Added tests for Java source config file discovery and content population; Added tests for Java source-to-CPG type resolution; Added tests for JavaSrc2Cpg HTTP server mode; Added tests for Jimple2CPG jar unpacking behavior; Added tests for Kotlin compiler API and Java interoperability; Added tests for Kotlin2CPG HTTP server mode and source file filtering; Added tests for Kotlin2Cpg dependency resolver V2; Added tests for PHP control flow, dependency resolution, and type recovery passes; Added tests for PHP dataflow analysis capabilities; Added tests for PHP scope resolution and import handling; Added tests for Python CPG generation passes; Added tests for Ruby config file inclusion and type recovery; Added tests for Ruby source-to-CPG HTTP server mode; Added tests for TypeRecoveryPass; Added tests for access path handling in the query engine; Added tests for javasrc2cpg utility components; Added tests for kotlin2cpg command-line argument parsing; Added tests for pysrc2cpg configuration and virtual environment exclusion; Added tests for rubysrc2cpg CLI argument parsing and default ignore regex; Added tests for the ABAP code property graph frontend; Added unit tests for Go AST creation passes; Added validation tests for Kotlin CPG generation; C\# frontend test coverage for AST querying; Expanded dataflow test coverage for Java source analysis; Expanded test coverage for Python source-to-CPG conversion; Initial data-flow tests for C\# frontend; New Kotlin test fixture with V3 validation and OSS dataflow support; New Ruby test fixtures with shared JRuby environment and validation; New test fixture for Python frontend validation and data flow testing; New test fixtures for Java source-to-CPG conversion and dataflow analysis; New test fixtures for data-flow analysis configuration; PHP2CPG querying test coverage expanded.

Dependencies

Upgrade to CodePropertyGraph 1.7.77 and Scala 3.8.3

The Joern build system has been updated to use CodePropertyGraph version 1.7.77 and Scala 3.8.3. This upgrade is accompanied by a requirement for JDK 13 or higher for the build process and the addition of a dependency override for Guava 33.5.0-jre to resolve a known bug in the Heros library.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 52 → 51 (-1.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 49 → 46 (-3.2)
  • Architecture 96 → 95 (-0.7)
  • Maturity 68 → 68 (+0.1)
  • Readiness 72 → 72 (-0.0)
  • Security 42 → 38 (-4.4)
  • Domain Modelling 100 → 100 (+0.0)

Resolved (45)

  • AstForDeclarationsCreator.astForDeconstruction (cognitive 16) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForDeclarationsCreator.scala)
  • AstForDeclarationsCreator.astForVariableDeclarator (cognitive 16) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForDeclarationsCreator.scala)
  • AstForExpressionsCreator.astForCppCallExpression (cyclomatic 17) (joern-cli/frontends/c2cpg/src/main/scala/io/joern/c2cpg/astcreation/AstForExpressionsCreator.scala)
  • AstForFunctionsCreator.createMethodAstAndNode (cognitive 16) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForFunctionsCreator.scala)
  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Duplicated block (11 lines × 2) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForDeclarationsCreator.scala)
  • Duplicated block (11–12 lines × 2) (joern-cli/frontends/swiftsrc2cpg/src/main/scala/io/joern/swiftsrc2cpg/astcreation/AstForDeclSyntaxCreator.scala)
  • Duplicated block (11–12 lines × 2) (querydb/src/main/scala/io/joern/scanners/c/FileOpRace.scala)
  • Duplicated block (12 lines × 2) (joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/ast/AstForExpressionsCreator.scala)
  • Duplicated block (13 lines × 2) (joern-cli/frontends/x2cpg/src/main/scala/io/joern/x2cpg/frontendspecific/jssrc2cpg/JavaScriptTypeRecovery.scala)
  • Duplicated block (16–17 lines × 2) (joern-cli/frontends/x2cpg/src/main/scala/io/joern/x2cpg/frontendspecific/jssrc2cpg/JavaScriptTypeRecovery.scala)
  • Duplicated block (18 lines × 2) (joern-cli/frontends/x2cpg/src/main/scala/io/joern/x2cpg/passes/controlflow/cfgcreation/CfgCreator.scala)
  • Duplicated block (20 lines × 2) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForStatementsCreator.scala)
  • Duplicated block (32 lines × 2) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForStatementsCreator.scala)
  • Duplicated block (35 lines × 2) (joern-cli/frontends/swiftsrc2cpg/src/main/scala/io/joern/swiftsrc2cpg/astcreation/AstForDeclSyntaxCreator.scala)
  • Duplicated block (3–9 lines × 3) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForTypesCreator.scala)
  • Duplicated block (5 lines × 2) (joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/ast/AstForPrimitivesCreator.scala)
  • Duplicated block (6 lines × 2) (joern-cli/frontends/x2cpg/src/main/scala/io/joern/x2cpg/utils/dependency/GradleDependencies.scala)
  • Duplicated block (7 lines × 2) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForDeclarationsCreator.scala)
  • Duplicated block (7 lines × 4) (joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/ast/AstForExpressionsCreator.scala)
  • …and 25 more

New (169)

  • AstForTypeDeclsCreator.astsForTypeDeclMembers (cognitive 22) (joern-cli/frontends/javasrc2cpg/src/main/scala/io/joern/javasrc2cpg/astcreation/declarations/AstForTypeDeclsCreator.scala)
  • AstForTypesCreator.astForClass (cognitive 23) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForTypesCreator.scala)
  • AstForTypesCreator.astForClass (cyclomatic 19) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForTypesCreator.scala)
  • AstForTypesCreator.astForClassMember (cognitive 31) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForTypesCreator.scala)
  • AstForTypesCreator.astForClassMember (cyclomatic 22) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForTypesCreator.scala)
  • Duplicated block (17 lines × 2) (joern-cli/frontends/x2cpg/src/main/scala/io/joern/x2cpg/passes/controlflow/cfgcreation/CfgCreator.scala)
  • Duplicated block (20 lines × 2) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForStatementsCreator.scala)
  • Duplicated block (32 lines × 2) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForStatementsCreator.scala)
  • Duplicated block (3–9 lines × 3) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForTypesCreator.scala)
  • Duplicated block (46–47 lines × 2) (joern-cli/frontends/swiftsrc2cpg/src/main/scala/io/joern/swiftsrc2cpg/astcreation/AstForDeclSyntaxCreator.scala)
  • Duplicated block (5 lines × 3) (joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/ast/AstForExpressionsCreator.scala)
  • Duplicated block (6 lines × 2) (joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/ast/AstForExpressionsCreator.scala)
  • Duplicated block (7 lines × 2) (joern-cli/frontends/jssrc2cpg/src/main/scala/io/joern/jssrc2cpg/astcreation/AstForDeclarationsCreator.scala)
  • Duplicated block (7 lines × 2) (joern-cli/frontends/x2cpg/src/main/scala/io/joern/x2cpg/frontendspecific/jssrc2cpg/JavaScriptTypeRecovery.scala)
  • Duplicated block (8–9 lines × 2) (joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/ast/AstForExpressionsCreator.scala)
  • Duplicated block (9 lines × 2) (joern-cli/frontends/x2cpg/src/main/scala/io/joern/x2cpg/frontendspecific/jssrc2cpg/JavaScriptTypeRecovery.scala)
  • Duplicated block (9 lines × 2) (semanticcpg/src/main/scala/io/shiftleft/semanticcpg/language/android/ConfigFileTraversal.scala)
  • Edited copies of one member (3 members, 14+ corresponding lines) (querydb/src/main/scala/io/joern/scanners/c/DangerousFunctions.scala)
  • Edited copies of one member (3 members, 22+ corresponding lines) (querydb/src/main/scala/io/joern/scanners/java/SQLInjection.scala)
  • Edited copies of one member (3 members, 32+ corresponding lines) (joern-cli/frontends/pysrc2cpg/src/main/scala/io/joern/pysrc2cpg/PythonAstVisitor.scala)
  • …and 149 more

Changes since last survey

  • 69 commits — 63 feature/other, 6 fixes

By area

  • joern-cli/frontends — 56 commits
  • dataflowengineoss/src — 7 commits
  • .github/workflows — 5 commits
  • (root) — 1 commit

Notable commits

  • fix: [rust2cpg] fix paren expr duplicate adjustments. (#6483)
  • fix: [rust2cpg] fix stackoverflow on nested macro-expanded receivers. (#6507)
  • fix: [rust2cpg] fix unresolved methodFullName when Fn is in scope. (#6533)
  • fix: dataflowengineoss: fix struct member assignment reachability via aliased pointers (#6446)
  • fix: fix(dataflowengineoss): normalize arithmetic DDG edges to prevent cross-operand linking (#6473)
  • fix: fix(dataflowengineoss): preserve reaching definitions for conditional operator conditions (#6472)
  • change: Bump the dependencies group with 2 updates (#6468)
  • change: Bump the dependencies group with 2 updates (#6481)
  • change: Bump the dependencies group with 4 updates (#6518)
  • change: Fix typos in documentation (#6484)
  • change: [CI] Bump sbt/setup-sbt to v1.5.14 (#6499)
  • change: [c2cpg] Decide a call's dispatch from virtuality, not from the virtual keyword (#6505)
  • change: [c2cpg] Do not drop C files whose _Alignas operand is the size of a type (#6466)
  • change: [c2cpg] Do not emit a call for a function call in an unevaluated operand (#6489)
  • change: [c2cpg] Do not give the ellipsis parameter the preceding parameter's type (#6523)
  • change: [c2cpg] Do not report every constructor as public (#6504)
  • change: [c2cpg] Give C functions whose name is in parentheses their full name (#6465)
  • change: [c2cpg] Give a reference to a const member function the method's full name (#6490)
  • change: [c2cpg] Give an array delete its own operator (#6515)
  • change: [c2cpg] Lower base-class and delegating constructor initializers as constructor calls (#6462)
  • …and 49 more

Architecture

  • Containers 0 added · 0 removed · contexts 0 added · 0 removed · edges 5 added · 118 removed

Added dependency edges (5)

  • abap2cpg → x2cpg
  • joern-cli → semanticcpg
  • pysrc2cpg → x2cpg
  • rust2cpg → x2cpg
  • swiftsrc2cpg → x2cpg

Removed dependency edges (was a dependency, now gone) (118)

  • abap2cpg → console (coupling)
  • abap2cpg → dataflowengineoss (coupling)
  • abap2cpg → pysrc2cpg (coupling)
  • abap2cpg → x2cpg (coupling)
  • c2cpg → abap2cpg
  • c2cpg → console (coupling)
  • c2cpg → dataflowengineoss (coupling)
  • c2cpg → pysrc2cpg (coupling)
  • console → dataflowengineoss (coupling)
  • console → pysrc2cpg (coupling)
  • csharpsrc2cpg → abap2cpg
  • csharpsrc2cpg → c2cpg
  • csharpsrc2cpg → console (coupling)
  • csharpsrc2cpg → dataflowengineoss (coupling)
  • csharpsrc2cpg → javasrc2cpg
  • csharpsrc2cpg → pysrc2cpg (coupling)
  • dataflowengineoss → jssrc2cpg
  • dataflowengineoss → pysrc2cpg (coupling)
  • dataflowengineoss → swiftsrc2cpg
  • gosrc2cpg → abap2cpg
  • …and 98 more

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

Survey your own repository

joernio/joern 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.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit eb6f32852e4f5fe9f4bddc9aa9c23aad418f6915 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.