Every question, answered once and in full.

KATAI 2D is free, open-source finite element software for geotechnical engineering. It analyses deformation, stability, groundwater flow, consolidation and seismic response of soil, rock and soil–structure systems in two dimensions — plane strain and axisymmetry — and is driven from a command line, from Python, or from a plain text project file. Its distinguishing principle is verification: every capability is pinned to a closed-form solution, an independent computation path or a published benchmark, and the record of 69 such cases ships with the source.

Practising geotechnical engineers who need deformation and stability analyses they can defend in a design review; researchers and students who need a finite element code whose formulation and source they can read and whose results they can reproduce; and anyone automating geotechnical analyses — parametric studies, back-analyses, optimisation — from Python or a build pipeline.

Supported excavations and retaining walls with anchors and struts; bearing capacity and settlement of shallow foundations and pile rows; slope and embankment stability by strength reduction; consolidation and creep of soft ground under staged fill; steady and transient seepage with free surfaces, wells and drains; seismic site response with absorbing boundaries; and rock masses and tunnels with the Hoek–Brown criterion. All of these are phases of one model and can be combined.

KATAI 2D is designed and written by Fatih Küçükkarakurt and published by KATAI Geotechnical Engineering. The source, the issue tracker and the release history are public at github.com/fkkarakurt/katai2d.

That no capability is considered finished until it reproduces an answer known independently of the program. Three kinds of evidence are admitted — a closed-form solution, an independent computation path sharing no code with the solver, or a published benchmark with its primary source cited — and self-consistency is not. The 69 cases are declared inside the tests that assert them, the public verification matrix is generated from those declarations, and the build fails if the two drift apart.

Yes. The engine, the katai command line and the Python package are open source under the Apache License 2.0, which permits commercial use, modification and redistribution without fee. There is no licence key, no dongle, no node-locking, no account and no time limit.

No. Apache-2.0 is a permissive licence, not a copyleft one. Your input files, results and scripts are yours, and you may build proprietary tools on top of the engine. If you redistribute the software itself you must keep its licence and notice files.

The open-source release is complete in itself and is not a trial of anything. A desktop application — drawing, meshing, staged construction, results and reporting on the same engine — is being developed as a separate track and is not part of the open-source release; its terms have not been announced.

No. The released binaries use the vendored Eigen linear algebra library (MPL-2.0) and nothing proprietary. A build from source may optionally use Intel oneMKL PARDISO for speed, and the suite verifies that both backends give the same answers.

Seven: Linear Elastic; Mohr–Coulomb with a tension cut-off and a dilatancy cut-off; Hardening Soil; HS small (Hardening Soil with small-strain stiffness); Soft Soil; Soft Soil Creep; and the generalised Hoek–Brown criterion (2002) for rock, entered as σci, mi, GSI and D. Each soil model can be drained, undrained (A), (B) or (C), or non-porous.

K0 procedure and gravity loading for the initial stress; plastic (staged construction) analysis; Biot consolidation with an elastoplastic skeleton; fully coupled flow–deformation; steady-state and transient groundwater flow; safety analysis by strength (φ–c) reduction; and dynamic time-history analysis. Each is a phase type, and phases of different types follow one another in one project.

Plates (walls, linings, slabs) with optional plastic moment and axial capacity; node-to-node anchors and struts with prestress and capacity limits; tension-only geogrids; embedded beam rows for pile rows with skin and base resistance; and zero-thickness interfaces with Coulomb strength derived from the adjacent soil. Force diagrams (N, Q, M) are returned along each member.

Yes. Axisymmetry is a separate formulation with the hoop strain carried and integration weighted by the radius, used for circular footings, shafts, single piles and deep circular tunnels. The Cox (1962) circular footing benchmark is reproduced to +3.7% and the Hoek–Brown tunnel case to 0.59% in axisymmetry.

Yes. Consolidation is a coupled Biot analysis in which displacement and excess pore pressure are solved together; a phase can run for a given time or until a target degree of consolidation or residual excess pore pressure is reached, and then reports how long that took. Creep (secondary compression) is modelled with Soft Soil Creep. The Terzaghi solution is reproduced to within 0.0061 on the degree of consolidation.

Yes, by the strength reduction method, as an initial procedure or after any construction phase. On the Griffiths & Lane (1999) Example 1 slope it gives 1.384 against the Bishop & Morgenstern chart value of 1.380. Because a strength-reduction factor with non-associated flow depends on the mesh, the program says so on every such run.

Yes: time-history analysis with Newmark integration, harmonic, Ricker or recorded input motions, a compliant base, free-field lateral boundaries, Rayleigh damping, optional plasticity during shaking, and response spectra. There is no liquefaction model.

Partial-factor catalogues for EN 1997-1 (Eurocode 7) Design Approaches 1 (both combinations), 2 and 3, and for the Turkish Building Earthquake Code TBDY 2018 (static and seismic), applied per phase.

Three-dimensional analysis (it is two-dimensional by design); liquefaction and cyclic pore-pressure generation; suction-dependent strength of unsaturated soil; large-deformation (updated mesh) analysis; discrete jointed rock. Released binaries are for Windows x64 only, and the open-source release has no graphical interface. These limits are stated on the features page rather than left to be discovered.

On problems with exact or published answers, measured on the input files that ship in the repository: Prandtl’s bearing capacity factor +0.6%; the Davis & Booker footing +1.4%; the Cox circular footing +3.7%; the Giroud rigid footing +1.1%; the Charny dam discharge +1.02%; Terzaghi consolidation −1.2% to −0.4%; resonance of a soil column −0.6% and −0.2%; a Hoek–Brown tunnel 0.59% and 0.72%; beam deflection −0.000%. The full record of 69 cases, with every tolerance band, is on the verification page.

Because you can rerun them. The 26 benchmark inputs are plain .k2d files checked into the repository under tests/corpus; the suite of 207 automated tests asserts each published number on every build, and continuous integration runs that suite on every push using only open-source components. Install the program, solve a corpus file, compare.

Four problems from the PLAXIS 2D Validation Manual were rebuilt from their problem statements and solved from checked-in files. The published PLAXIS values are quoted unchanged (PLAXIS was not re-run). Against the analytic solutions: strip footing on elastic soil, PLAXIS +0.6%, KATAI 2D +1.1%; circular footing, PLAXIS −2.5%, KATAI 2D +3.7%; footing on clay with strength increasing with depth, PLAXIS +0.8%, KATAI 2D +1.4%; and the Gibson soil settlement, KATAI 2D −3.4% from the published finite-layer value. The comparison is documented case by case on this site.

It refuses, with a message that says why. A load drawn off the mesh, an analysis that is not defined for a material, an input that breaks a physical contract — each stops the run with a stable diagnostic code instead of producing a plausible number. Where a result is valid but needs qualifying, such as a mesh-dependent factor of safety, the qualification is printed with the result. There are 37 such codes, and the property behind them — that no input is discarded in silence — is itself a verification case in the suite.

More than one residual. The program computes the global force error, the current stiffness parameter and the local error at every stress point, applies all of them, and writes into the results file which were met and how many stress points were inaccurate. On the verification case, a run that satisfies only the global criterion has local errors 63 000 times larger than its global one.

Every finite element answer does, and the question is by how much. KATAI 2D implements the grid-convergence procedure of Roache and Celik et al. to measure it: for elastic stresses the extrapolated value approaches the closed form; for consolidation the time step is the governing axis and the error band is ±0.25%; for a strength-reduction factor of safety with non-associated flow the value falls about 4% over a fourfold refinement. These measurements are published in the repository, including the cases where the mesh turned out not to be the source of the error.

Yes, and they are published. In release 0.9.0: HS small accumulates strain history as a scalar and does not detect load reversals automatically; the Mohr–Coulomb failure bound stalls 0.24% below its plateau in a drained triaxial test; undrained triaxial paths of the Hardening Soil family are not yet pinned to published laboratory curves; unsaturated flow is verified only in its saturated limit; and four analyses are refused outright for Hoek–Brown rock. The changelog lists them under “Known limits”.

For the command line, run one line in PowerShell: irm https://raw.githubusercontent.com/fkkarakurt/katai2d/main/install.ps1 | iex — it downloads the latest release, verifies its SHA-256 and puts katai on your PATH, without administrator rights. For Python, download the wheel from the GitHub releases page and pip install it; one wheel serves every CPython from 3.12 onwards. Publication on PyPI is planned.

Released binaries are for Windows 10 or later, 64-bit. The engine builds and runs its entire test suite with the vendored Eigen solver and no proprietary component, which is the route to other platforms; no Linux or macOS binaries are published yet.

Not in the open-source release, which is a command line and a Python package. A desktop application with drawing, meshing, staged construction, result contours, force diagrams and report generation is in development on the same engine as a separate track; real screenshots are on the desktop page, and there is a list to join for the preview.

In Python, in a few lines: create materials, draw polygons or rectangles, add water, loads and structures, define phases, run. Or write the .k2d project file directly — it is documented JSON with a published schema. A script can save its model as a .k2d file at any point, and the command line solves that file unchanged.

Fixed units, stated in every docstring: kilonewtons, metres and days (seconds in dynamic phases). Stresses are therefore in kN/m² (kPa), unit weights in kN/m³ and permeabilities in m/day. There is no unit setting to get wrong.

The Griffiths & Lane slope benchmark — a safety analysis driven to failure — solves in about eight seconds from the command line on a 2017 laptop with the open-source solver; a footing loaded and then taken to a factor of safety takes about forty seconds from Python. Run time is dominated by plasticity near failure and by the number of phases, not by start-up or licensing.

Yes; that is what the command line is for. katai validate checks a project without solving, katai solve runs it, and the exit codes (0, 2, 3, 4, 5) are documented and pinned by a test, so a pipeline can tell a refused input from a failed solve. From Python, a parametric study is an ordinary loop.

Check the build you actually have: katai info, or python -c "import katai; print(katai.__version__)". Every front end reads one constant, so that number is the build’s real identity. The Python surface grew in 0.8.0 (prj.structures, katai.summary, the flow phases) and again in 0.9.0 (hoek_brown, consolidation targets); an earlier wheel will not have them. Files are guarded in the other direction: a project written by a newer build is refused by an older one rather than misread.

The executable is not yet code-signed and comes from a young project, which can trigger a generic reputation-based warning. Verify the download against the SHA-256 published with the release, or build from source, or use the Python wheel, which has never been flagged. Code signing is on the roadmap.

For two-dimensional analyses within its stated scope, yes: it offers the same family of constitutive models (Mohr–Coulomb, Hardening Soil, HS small, Soft Soil, Soft Soil Creep, Hoek–Brown), staged construction, consolidation, flow, safety and dynamic analysis, and it reproduces four published validation cases of that program to within a few percent of the analytic solutions. It differs in being open source, free, scriptable from the start and command-line driven — and in what it lacks: no 3D, no liquefaction models, and no graphical interface in the open-source release.

A limit-equilibrium program searches over assumed slip surfaces and returns a factor of safety. KATAI 2D solves the stress–strain problem: it returns deformations, pore pressures and structural forces at every construction stage, and its factor of safety comes from strength reduction with no assumed surface. On homogeneous slopes the two agree within a few percent; they differ where the mechanism is not one the slice method was asked to consider.

It is built for geotechnics rather than adapted to it: effective stress and pore pressure are first-class, the constitutive models are soil and rock models, initial stresses come from a K0 procedure, construction is staged with inherited activation, and the structural elements are the ones a retaining wall or a pile row needs. The verification record is made of geotechnical benchmarks — Prandtl, Terzaghi, Charny, Griffiths & Lane — not patch tests alone.

No import of other programs’ project files is provided. The .k2d format is plain documented JSON with a schema, so writing a converter from another source is straightforward, and the Python API builds a model from any data you can load.

Cite the software through its archived record: Küçükkarakurt, F. (2026). KATAI 2D: an open-source, verification-first finite element engine for geotechnical engineering. Zenodo. https://doi.org/10.5281/zenodo.20692282. A CITATION.cff file ships in the repository, so GitHub’s “Cite this repository” button produces the same entry. Where a specific number matters, cite also the primary source the verification matrix names for that case.

Open an issue using the “numerical result” template: state the computed value and the reference value with its source. It will be resolved against primary sources — and if the program is wrong, the fix arrives with a verification case so that it stays fixed. Several entries in the changelog are exactly that.

Yes, under one rule that is not negotiable: a capability that is not verified is not in the product. A contribution that adds a feature adds the closed-form solution, independent path or published benchmark that pins it, declared inside its test.

The input format is documented field by field with a JSON Schema; every diagnostic code has an entry; the verification matrix and its bibliography are generated from the tests; the numerical-uncertainty record states how far computed numbers sit from the exact solution of their own equations; and the Scientific Manual is archived with a DOI. All of it is in the docs folder of the repository, and this site summarises it page by page.

Yes. Release 0.9.0 was published on 31 August 2026, the fifth release that month, and development continues in the public repository, where the changelog records every change and which wrong answers it fixed.