RiSE4fun toolshttps://rise4fun.com/List of tools available on RiSE4funen-US<a target='_blank' href='https://go.microsoft.com/?linkid=2028325'>Contact Us</a>| <a target='_blank' href='https://go.microsoft.com/fwlink/?LinkId=521839'>Privacy &amp; Cookies</a> | <a target='_blank' href='https://go.microsoft.com/fwlink/?LinkID=246338'>Terms of Use</a> | <a target='_blank' href='https://go.microsoft.com/fwlink/?LinkId=506942 '>Trademarks</a>| &copy; 2018 Microsofthttps://rise4fun.com//Images/Rise.gifRiSE4fun toolshttps://rise4fun.com/https://rise4fun.com/AglAglAgl is built on the principle of the Sugiyama scheme; it produces so called layered, or hierarchical layouts. This kind of a layout naturally applies to graphs with some flow of information.https://rise4fun.com/AliveAliveAlive proves correctness of peephole optimizations.https://rise4fun.com/BekBekWith BEK, you can answer questions like Do these two programs output the same string? Can this program ever output a target string? What happens if I compose these two programs? Does the order matter? More general than regular expressions, BEK has been specifically tailored to capture common idioms in string manipulating functions.https://rise4fun.com/BexBexWith bex, you can answer prove the correctness of string coders.https://rise4fun.com/BoogieBoogieBoogie is an intermediate verification language, intended as a layer on which to build program verifiers for other languages.https://rise4fun.com/ChaliceChaliceChalice is a simple imperative programming language with constructs for thread creation, locking, and channels. The language has built-in specification constructs, and specifications are written in the style of implicit dynamic frames with fractional permissions.https://rise4fun.com/CivlCivlCivl is a an extension to the Boogie intermediate verification language, intended for reasoning about concurrency.https://rise4fun.com/CodeContractsCode ContractsCode Contracts provide a language-agnostic solution to the problem of software specification and validation. They consist of an API (part of .NET) to author contracts, and several tools consuming it (e.g., code documentation, runtime checking, and static checking). The static checker, based on abstract interpretation, infers semantic facts and uses them to prove contracts, programmer-provided and language assertions. Furthermore, it helps the development process by providing verified code repairs.https://rise4fun.com/CounterdogCounterdogCounterdog is an automated theorem-prover for a counterfactual meta-logic about propositional Datalog programs. It is useful, for example, for reasoning about Datalog-based trust management and authorization languages.https://rise4fun.com/DafnyDafnyDafny is a programming language with imperative and functional features, as well as specification constructs for describing intended behavior. The Dafny verifier checks that programs live up to their specifications.https://rise4fun.com/DIFTDIFTThis tool is a prototype typechecker for Dependent Information Flow Types, based on the algorithm described in the POPL 2015 paper (see website).https://rise4fun.com/EldaricaEldaricaEldarica is a model checker for Horn clauses in various formats, numerical transition systems, and software programs written in dialects of Scala or C.https://rise4fun.com/EsmEsmEsm focus on understanding various software development issues from an empirical perspective. We are involved in doing practical studies on large software systems.https://rise4fun.com/FastFastWith FAST, you can answer questions like Can this program ever output a target tree? What happens if I compose these two programs?https://rise4fun.com/FormulaFormulaFORMULA is a modern formal specification language targeting model-based development (MBD). It is based on algebraic data types (ADTs) and strongly-typed constraint logic programming (CLP), which support concise specifications of abstractions and model transformations. Around this core is a set of composition operators for composing specifications in the style of MBD.https://rise4fun.com/Formula2Formula2FORMULA is a modern formal specification language targeting model-based development (MBD). It is based on algebraic data types (ADTs) and strongly-typed constraint logic programming (CLP), which support concise specifications of abstractions and model transformations. Around this core is a set of composition operators for composing specifications in the style of MBD.https://rise4fun.com/GPUVerify-CUDAGPUVerify-CUDAThis tool checks that a kernel is free from assertion failures, data races and barrier divergence.https://rise4fun.com/GPUVerify-OpenCLGPUVerify-OpenCLThis tool checks that a kernel is free from assertion failures, data races and barrier divergence.https://rise4fun.com/GraVyGraVyWe present a gradual static verifier, GraVy. For a given piece Java of code, GraVy identifies a subset of statements for which it can prove that exceptional termination is impossible. That is, even though some statements still may terminate exceptionally, GraVy still computes a partial result. This allows us to measure the progress of static verification.https://rise4fun.com/HeapDbgHeapDbgAbstraction and visualization of heapshttps://rise4fun.com/iZ3iZ3iZ3 is a high-performance interpolating theorem prover. iZ3 supports arithmetic, arrays, uninterpreted functions, and quantifiers.https://rise4fun.com/JoogieJoogieWe present Joogie, a tool that detects infeasible code in Java programs. Infeasible code is code that is either not forward- or backward-reachable. Infeasible code comprises many errors detected by static analysis in modern IDEs such as guaranteed null-pointer dereference or unreachable code. The intriguing property of infeasible code is that it can be detected in a modular, cheap, and precise way.Unlike existing techniques, Joogie identifies infeasible code by proving that a particular statement cannot occur on a terminating execution using techniques from static verification. Thus, Joogie is able to detect infeasible code which is overlooked by existing tools. Joogie works fully automatic, it does not require user-provided specifications and (almost) never produces false warnings.https://rise4fun.com/KokaKokaKoka is a function-oriented programming language that separates pure values from side-effecting computations. Koka has many features that help programmers to easily change their data types and code organization correctly, while having a small language core with a familiar JavaScript like syntax.https://rise4fun.com/OpenJMLESCOpenJML (ESC)OpenJML is a program verification tool for Java programs that allows you to check the specifications of programs annotated in the Java Modeling Language.https://rise4fun.com/QuickCodeQuickCodeA progamming-by-example technology for learning string transformation programs. Part of this technology will ship as part of the Flash Fill feature in Excel in Office 2013. https://rise4fun.com/RevisionsConcurrent RevisionsRevisions provides programmers with a simple, yet powerful and efficient mechanism to execute various application tasks in parallel even if those tasks access the same data and may exhibit read-write or write-write conflicts. Revisions is based on mutable snapshots and deterministic conflict resolution.https://rise4fun.com/RexRexRex turns regular expressions into Symbolic Automatons and applies state of art technique to generate members.https://rise4fun.com/SAMLSAMLFormal language for discrete state-based system modelling. Part of the Verification Environment for Critical Systems (VECS)https://rise4fun.com/SealSealA static analysis that determines the side-effects of a methodhttps://rise4fun.com/SpecSharpSpec#Spec# is a formal language for API contracts (influenced by JML, AsmL, and Eiffel), which extends C# with constructs for non-null types, preconditions, postconditions, and object invariants. Spec# comes with a sound programming methodology that permits specification and reasoning about object invariants even in the presence of callbacks and multi-threading.https://rise4fun.com/VccVccVCC is a tool that proves correctness of annotated concurrent C programs or finds problems in them. VCC extends C with design by contract features, like pre- and postcondition as well as type invariants. Annotated programs are translated to logical formulas using the Boogie tool, which passes them to an automated SMT solver Z3 to check their validity.https://rise4fun.com/Z3Z3Z3 is a high-performance theorem prover. Z3 supports arithmetic, fixed-size bit-vectors, extensional arrays, datatypes, uninterpreted functions, and quantifiers.