Open Source Risk Engine (ORE) ia an Open Source Software project, designed for contemporary pricing and risk analytics of traded financial products. It aims at establishing a transparent peer-reviewed framework that can serve as benchmarking, validation, training, teaching reference, as well as extensible foundation for in-house and vendor solutions. ORE is provided under the Modified BSD license.
QuantLib is the open source library for quantitative finance, see www.quantlib.org. ORE uses QuantLib heavily.
Yes, a user guide is available here for download on opensourcerisk.org.
Not yet, please feel free to contribute your experience with ORE in the form of a tutorial.
Not yet, but we are working on an ORE book for that purpose.
ORE is written in C++. ORE consists of three libraries (QuantExt, OREData and OREAnalytics) and a command line application that demonstrates how ORE’s functionality can be used. QuantExt uses C++98 in line with QuantLib and to facilitate migrating code from QuantExt to QuantLib over time. The Data and Analytics libraries use C++11 for convenience.
That’s a good idea. We will add to opensourcerisk.org as we become aware of institutions using it (and when the institutions agree to publishing this).
Yes, the ORE framework is used in production. We have started a case studies page on opensourcerisk.org to list cases we are aware of and that we are allowed to post.
We have created a forum page on opensourcerisk.org to enable exchange between users and developers from day one. You can also subscribe there to get notified when there are updates in the forum, or just go there and browse the forum entries.
Certainly, we would encourage people to talk about ORE publicly and help promoting the idea. Members of the project sponsor are doing this already and will continue to do so.
It is open source, so your IT can scan it for any malware, and your model validation can check down to the last line of code. Whether it is secure in the sense of ‘correct implementation of methods’ – this is at least partially ensured by the unit test suites in ORE and should be further confirmed over time by peer review. In the end, you will have to judge, and fortunately this is possible, because it isn’t a black box but open source.
Quantlib went through major restructuring in the early days. How do I know the same isn’t going to happen with the ORE, which means I’ll have to do all the integration work again in the future?
Good point. ORE has not bee designed from scratch at the drawing board. OREs architecture grew out of years of industry experience the Quaternion team has as users, developers and consultants. We are confident that the current software design is robust. However the great thing about Open Source is “using the wisdom of crowds” to get feedback and improve on the original. Hence we can not exclude that the “API” will keep changing over the first releases. Please get involved and if necessary help us make it converge quickly!
It is a culmination of years of experience (approximately ~10 person years joint coding effort – real blood, sweat and tears!) and the desire to ‘leave something behind’ that is tangible and hopefully useful. We think that ORE will further strengthen Quaternion’s position as a global risk analytics provider. Finally, we also offer our consulting and development services around ORE itself, as well as our licensed extensions of ORE.
ORE is an application that provides a Monte Carlo simulation framework for contemporary risk analytics and value adjustments, simple interfaces (for trade data, market data and system configuration), simple launchers and result visualisation (with Jupyter, Excel, LibreOffice), unit tests and various examples. The first release covers ‘plain vanilla’ interest rate and foreign exchange derivatives.
Why should I use ORE instead of (or what is the difference to) other open source Risk Engines (e.g. : http://www.openriskcalculator.com/).
ORE is unique in that that it is based on the wealth of methods provided by QuantLib, a peer reviewed pricing library that has evolved over 15 years. We try to avoid reinventing the wheel where possible. ORE is written in C++ with both model validation and production environemts in mind. ORE comes with a user guide, tests and examples, and the sponsor is committed to grow ORE quickly into Inflation, Credit, Equity and Commodity space.
Can ORE be setup, adapted for specific needs and integrated to the IT landscape by an experienced quant/IT professional, or would I need to hire Quaternion to do that?
We are convinced that ORE can be adapted and integrated by experienced professionals. Of course, Quaternion can assist and are able to accelerate implementation and adaptation timelines.
Open Source Risk Engine’s code is hosted on github. You can either fetch the repository using git from https://github.com/OpenSourceRisk/Engine or download a release archive from https://github.com/OpenSourceRiskEngine/releases
Most likely yes – follow the instructions in “Where can I get it?” and fetch the latest ORE release. It comes with ORE executables for several platforms including Windows, Linux and Mac OS X.
ORE works on Windows, Linux, Mac OS X and possibly other Unix flavours (we have tested it with the former three). The ORE releases come with executables for these platforms so that you do not need to go through the building of ORE in order to get started. If you want to build ORE from sources, then the user guide’s section 3 provides the step-by-step guidance and tells you what is required.
Please check out our user guide. This explains in section 3 how ORE is installed on Windows and Unix (Mac/Linux).
Please check out our user guide. This explains in section 3 how ORE is installed on Windows and Unix (Mac/Linux).
To get started you do not need to have any programming knowledge. Head to our download page at https://github.com/OpenSourceRisk/Engine/releases and fetch the latest release archive. It contains the ORE executable for several platforms, ready to run. ORE’s user guide explains the first steps and provides a number of examples that illustrate how ORE can be used. Modify these examples to create your own.
Open Source Risk Engine (ORE) expects market data to be provided in a specific format as explained in the user guide. Any provider’s market data needs to be mapped to this format. Alternatively, you can extend ORE by adding a tailored market data loader which can absorb the provider’s data directly and load it into ORE.
Portfolio data is provided by the user. ORE expects a specific XML file representation of the trade data as explained in the user guide. ORE comes with its own XML trade data loader that directly maps to ORE’s internal representation of supported product types. In the ‘Examples’ section of the release, you will find various examples of such trade XML files covering all products that are currently handled in ORE.
If you need help, consult with these FAQs first, then browse/search the user forum discussions and feel free to ask questions in the user forum. If you have found an issue you can log this in our issue tracker at https://github.com/OpenSourceRisk/Engine/issues.
You can log issues and bugs at https://github.com/OpenSourceRisk/Engine/issues. Moreover you can post any issue you find in the user forum at opensourcerisk.org.
Make sure “ore_examples_helper.py” in the Examples folder is referring to the right locations for ore.exe. This can be achieved by moving the executable into the “bin” directory as explained in the user guide. Alternativerly, one can edit “ore_examples_helper.py” to refer to the actual location of the executable.
We appreciate any feedback you post in the user forum at openriskengine.org. If you want to contribute code changes and extensions, then please fork the ORE repository at https://github.com/OpenSourceRisk/Engine and start coding. Changes and additions can then be provided in the form of pull requests at https://github.com/OpenSourceRisk/Engine/pulls.
Is it necessary to have deep QuantLib knowledge to extend the ORE, e.g. adding a different model for calculating exposure or pricing?
ORE is based on QuantLib and uses QuantLib style especially in its “QuantExt” library. Adding different simulation models starts there so that familiarity with QuantLib is an advantage. Further amendments are then also required in the data and analytics libraries closer to the application layer. The design of the latter two libraries is less QuantLib-style.
Yes, you can. However, our style is to (re-)write additional pricers in QuantLib style and place them in ORE’s QuantExt library.
Absolutely. ORE will initially provide one market simulation modelling approach per risk factor class, but we are very open to adding more alternatives. This is what the community needs for benchmarking in our opinion. We would suggest that you start with exploring the methodology (see user guide appendix) and then continue checking how this is implemented in the QuantExt, OREData and OREAnalytics libraries.
You can integrate ORE analytics in several ways: One is to map your market and trade data to the input file formats we have defined and that can be readily loaded into ORE; this means a classic interface/adapter development task that is typically moderate compared to the effort of getting and cleansing the data from the source systems. Thereafter you can run the ORE command line application for example in a series of batches to produce the desired analytics results. The resulting reports can be picked up from the file system, parsed and imported into the target system. Another approach would be tighter integration that uses ORE’s C++ API directly without using the ORE file formats or the command line application that comes with the ORE release.
Clean design, avoiding duplication, a comprehensive test suite, variety of example and demo cases are measures to continuously assure the quality of release. Peer review of the first release will further harden ORE. When we extend ORE, we will make sure that corresponding test cases are added to the test suites. Any contributions submitted by the community are carefully reviewed and may be discussed in the forum before being integrated into ORE. Also refer to the ORE contribution and governance page at openriskengine.org.
ORE does not cover the entire range of QuantLib instruments. For example, Inflation Swaps and Credit Default Swaps are in QuantLib though not accessible via ORE yet. That will change with the next releases (see the roadmap).
Feature X is not yet in ORE but on the roadmap. Is there a way to accelerate development and release of this feature?
ORE is an open source project driven by the community. There is an outline roadmap but the best way to make a desired feature appear quickly is to contribute to its development.
Yes, normal and shifted lognormal volatilities are fully supported on the basis of the QuantLib framework.
Yes there is, you can find it on opensourcerisk.org. The roadmap outlines a future direction for ORE. Quaternion remains committed to showcasing the releases and sponsoring ORE’s developments. However, the order in which features are added is not yet fixed and depends, to a certain extent, on the feedback from the community after the first release.
ORE can ‘absorb’ most of the market data relevant for pricing IR/FX products and more, in anticipation of subsequent releases. For example, market data comprises yield curve data (Deposits, FRAs, Futures, Swaps, Tenor Basis Spreads, Cross Currency Basis Spreads), FX spot rates, FX forward rates, Cap/Floor and Swaption volatilities, as well as CDS data to build default curves, etc. See the user guide for details.
Not out of the box. However, ORE comes with a market data loader that expects a certain market data file format as described in the user guide. To link into any specific data provider, you can either map the provider’s data to ORE’s market data input file format or extend ORE and add a custom market data loader that processes the provider’s input directly.
Not out of the box. However, ORE comes with its own XML trade data loader that directly maps to ORE’s internal representation of supported product types (see user guide). To handle trade data that comes in FpML format, you could either map this to ORE’s xml format or develop a custom trade data loader that processes FpML directly.
Not at all! ORE builds on the work of QuantLib. And we grateful for the enormous community effort and experience that went into QuantLib which has enabled ORE.