{"id":37022674,"url":"https://github.com/uuverifiers/ostrich","last_synced_at":"2026-01-14T02:42:42.443Z","repository":{"id":37699969,"uuid":"174158308","full_name":"uuverifiers/ostrich","owner":"uuverifiers","description":"An SMT Solver for string constraints","archived":false,"fork":false,"pushed_at":"2025-12-23T19:18:16.000Z","size":243390,"stargazers_count":48,"open_issues_count":20,"forks_count":8,"subscribers_count":3,"default_branch":"master","last_synced_at":"2025-12-25T09:41:57.187Z","etag":null,"topics":["regular-expressions","smt-solver","strings","theorem-prover","theorem-proving"],"latest_commit_sha":null,"homepage":"","language":"Scala","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/uuverifiers.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":"AUTHORS","dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2019-03-06T14:15:28.000Z","updated_at":"2025-12-23T19:00:57.000Z","dependencies_parsed_at":"2023-02-12T18:15:24.997Z","dependency_job_id":"a0c347b0-47dd-4717-a62c-2d405c29758c","html_url":"https://github.com/uuverifiers/ostrich","commit_stats":null,"previous_names":[],"tags_count":8,"template":false,"template_full_name":null,"purl":"pkg:github/uuverifiers/ostrich","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/uuverifiers%2Fostrich","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/uuverifiers%2Fostrich/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/uuverifiers%2Fostrich/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/uuverifiers%2Fostrich/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/uuverifiers","download_url":"https://codeload.github.com/uuverifiers/ostrich/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/uuverifiers%2Fostrich/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28408712,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-14T01:52:23.358Z","status":"online","status_checked_at":"2026-01-14T02:00:06.678Z","response_time":107,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["regular-expressions","smt-solver","strings","theorem-prover","theorem-proving"],"created_at":"2026-01-14T02:42:41.815Z","updated_at":"2026-01-14T02:42:42.423Z","avatar_url":"https://github.com/uuverifiers.png","language":"Scala","readme":"# OSTRICH\n## An SMT Solver for String Constraints\n\nOSTRICH is an automata-based SMT solver for string constraints.\n\nThe theory behind OSTRICH is explained in the slides of our [POPL'24 tutorial.](https://eldarica.org/ostrich-popl24/)\n\n## Using Ostrich\n\nAfter installing [the Scala Build tool (SBT)](https://www.scala-sbt.org/), you can assemble a JAR file using `sbt assembly`. To run it, use either the `ostrich` script in the root folder, or `ostrich-client`. The latter transparently spins up a server that continuously serves requests from the client script; useful to avoid cold-starting the JVM if you are running many instances.\n\nIn general, OSTRICH supports all options of the [Princess SMT solver](https://github.com/uuverifiers/princess), which can be displayed with `./ostrich -h`.\n\nThere are some additional string-specific options offered by OSTRICH:\n\n| Option                    | Explanation                                                                                  |\n|---------------------------|----------------------------------------------------------------------------------------------|\n| `[+-]cea`                 | Use the cost-enriched automata back-end instead of the standard back-end. Default: `-cea`    |\n| `-portfolio=strings`      | Use a portfolio of different string solving configurations. Disabled by default.             |\n| `[+-]forwardPropagation`  | Forward propagation of regular expression constraints. Default: `-forwardPropagation`        |\n| `[+-]backwardPropagation` | Backward propagation of regular expression constraints. Default: `+backwardPropagation`      |\n| `[+-]nielsenSplitter`     | Splitting of equations using Nielsen transformation. Default: `+nielsenSplitter`             |\n| `-length=[on,off,auto]`   | Switch length reasoning on or off. Default: `-length=auto`                                   |\n| `[+-]parikh`              | Introduce letter count equations for all letters that occur in a problem. Default: `-parikh` | \n| `[+-]minimizeAutomata`    | Eager minimization of automata. Default: `-minimizeAutomata`                                 |\n| `[+-]eager`               | Eager intersection of regular expression constraints. Default: `-eager`                      |\n\n## Web Interface\n\nFor experiments, OSTRICH can also be used through its [web interface.](https://eldarica.org/ostrich/)\n\n## Input Format\n\nOSTRICH accepts constraints written using the [SMT-LIB theory of strings](http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml).\n\nIn addition to the standardized SMT-LIB operators, OSTRICH can handle a number of further functions.\n\n### Additional string functions\n\n| Name        | Explanation      |\n|-------------|------------------|\n| str.reverse | Reverse a string |\n\n### Unary transducers\n\nFinite-state transducers are a general way to introduce further string functions. Examples of functions that can be represented as transducers are encoders, decoders, extraction of sub-strings, removal of white-space characters, etc.\n\nFinite-state transducers can be defined as (mutually) recursive functions, see [this file](../master/tests/transducer1.smt2) for an example.\n\nIt is also possible to use prioritised finite-state transducers: multiple outgoing transitions from a state can be given priorities, and the transducer will take the transition with highest priority that will lead to a successful run. See [this file](../master/tests/priorityTransducer.smt2) for an example.\n\n### Additional regular expression constructors\n\n| Name        | Explanation      |\n|-------------|------------------|\n| re.from_ecma2020 | Parse a regular expression in textual ECMAScript 2020 format [(example)](../master/tests/parse-ecma-cases.smt2) |\n| re.from_ecma2020_flags | Parse a regular expression in textual ECMAScript 2020 format, with a second argument to specify flags [(example)](../master/tests/parse-ecma-cases.smt2) |\n| re.case_insensitive | Make any regular expression case insensitive [(example)](../master/tests/case-insensitive.smt2) |\n| re.from_automaton |  Parse a finite-state automaton [(example)](../master/tests/automata.smt2) |\n\n\n### Handling of capture groups\n\nOSTRICH can also process regular expressions that include capture groups, lazy quantifiers, and anchors. For this functionality, OSTRICH understands a number of additional regular expression operators:\n\n| Name                 | Explanation                                                                 |\n|----------------------|-----------------------------------------------------------------------------|\n| re.*?                | Non-greedy star: similar to re.* but matching as few characters as possible |\n| re.+?                | Non-greedy plus                                                             |\n| re.opt?              | Non-greedy option                                                           |\n| (_ re.loop? a b)     | Non-greedy loop                                                             |\n| (_ re.capture n)     | Capture group with index n                                                  |\n| (_ re.reference n)   | Reference to the contents of capture group n                                |\n| re.begin-anchor      | The anchor ^                                                                |\n| re.end-anchor        | The anchor $                                                                |\n\nSuch augmented regular expressions can be used in combination with several new string functions. Those functions support in particular capture groups and references in the replacement strings:\n\n| Name               | Explanation                                                                                          |\n|--------------------|------------------------------------------------------------------------------------------------------|\n| (_ str.extract n)  | Extract the contents of the n'th capture group ([example](../master/tests/extract-cg.smt2))          |\n| str.replace_cg     | Replace the first match of a regular expression ([example](../master/tests/parse-ecma-replace.smt2)) |\n| str.replace_cg_all | Replace all matches of a regular expression ([example](../master/tests/regex_cg_ref.smt2))           |\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fuuverifiers%2Fostrich","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fuuverifiers%2Fostrich","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fuuverifiers%2Fostrich/lists"}