The fol­low­ing pages provide a high-level over­view of the fea­ture set offered by Mag­num. For great­er de­tail please read doc­u­ment­a­tion linked from the sec­tions be­low. You can also click on vari­ous parts of the ar­chi­tec­ture dia­gram.

Our “Zen Garden” philo­sophy

  • Con­sist­ent cod­ing, build­ing, test­ing and de­ploy­ing ex­per­i­ence across all plat­forms
  • Light­weight core with mod­u­lar and ex­tens­ible ad­dons that en­able di­verse use cases
  • Clean code with high test cov­er­age, built and tested at least once a week on all plat­forms to en­sure con­tinu­ous re­li­ab­il­ity and sta­bil­ity
  • Act­ively main­tained ex­tens­ive doc­u­ment­a­tion
  • First-class sup­port and friendly com­munity (Git­ter chat, mail­ing list)
  • Premi­um sup­port and con­sult­ing of­fers (see the Premi­um Ser­vices page for de­tails)

Sup­por­ted plat­forms

  • Linux and em­bed­ded Linux
  • Win­dows with MS­VC, clang-cl and MinGW, Win­dows RT (Store/Phone)
  • ma­cOS, iOS
  • An­droid
  • Web (WebAssembly or asm.js), through Em­scripten

Plat­form ab­strac­tion

Cor­rade is a stan­dalone lib­rary that forms the base de­pend­ency for Mag­num. In its min­im­al form it provides plat­form ab­strac­tion and low-level util­it­ies that are not dir­ectly re­lated to graph­ics. See the Cor­rade pro­ject page for de­tails.

Low-level util­it­ies

Set of con­veni­ence classes and func­tions to make writ­ing of com­mand-line ap­plic­a­tions ac­tu­ally en­joy­able; with min­im­al dif­fer­ences across vari­ous desktop, mo­bile and web plat­forms.

  • OS, filesys­tem and ter­min­al en­vir­on­ment ac­cess with con­sist­ent UTF-8 en­cod­ing across all plat­forms
  • Colored out­put that prints to con­sole on desktop and iOS, browser con­sole on web and lo­gcat on An­droid
  • String, Uni­code, hash­ing and oth­er util­it­ies

Simple con­tain­ers

Data struc­ture im­ple­ment­a­tions that have no dir­ect equi­val­ent in the STL or are bet­ter tailored to spe­cif­ic use cases than equi­val­ent gen­er­al stand­ard im­ple­ment­a­tions. Some are present simply to bridge dif­fer­ences between C++11, C++14 and C++17.

  • Light­weight C ar­ray wrap­pers with abil­ity to con­trol item ini­tial­iz­a­tion
  • Non-own­ing ar­ray views with util­it­ies for ar­ray sli­cing and cast­ing
  • Type-safe bit­fields, in­trus­ive list and more

Core API

The base Mag­num lib­rary con­tains the min­im­al set of APIs for graph­ics de­vel­op­ment. Apart from Cor­rade it has no ex­tern­al de­pend­en­cies to make port­ing to new plat­forms as fric­tion­less as pos­sible.

Math lib­rary

De­signed primar­ily for graph­ics with em­phas­is on im­ple­ment­a­tion sim­pli­city and de­bug per­form­ance. Provides vec­tor and mat­rix op­er­a­tions, com­plex num­bers, qua­ternions and their dual coun­ter­parts. In­tu­it­ive trans­form­a­tion APIs in both 2D and 3D.

  • Strong types and lit­er­als for en­ter­ing ra­di­ans, de­grees and half-floats
  • Hex col­or lit­er­als, sR­GB, HSV and XYZ col­or­space sup­port
  • Dis­tance and in­ter­sec­tion cal­cu­la­tion, mat­rix de­com­pos­i­tion al­gorithms

Ex­tra Func­tion­al­ity »

While you can stay with just the core Mag­num lib­rary, there are ad­di­tion­al opt-in lib­rar­ies and tools provid­ing fea­tures that can make de­vel­op­ment of your ap­plic­a­tion easi­er. OpenGL and Vulkan wrap­per lay­er, APIs for as­set man­age­ment, mesh, tex­ture and shader tools, de­bug­ging and pro­to­typ­ing util­it­ies, com­mand-line util­it­ies and much more.

Plu­gins & Ex­ten­sions »

The lib­rar­ies are ex­tens­ible via plu­gins for as­set load­ing and con­ver­sion or, for ex­ample, text ren­der­ing. Mag­num provides a rich set of plu­gins for load­ing com­mon im­age and scene formats, au­dio formats and im­age format con­ver­sion. It’s also pos­sible to in­teg­rate math lib­rary of your choice for seam­less use with core Mag­num APIs.

Com­mu­nity Con­tri­bu­tions »

On top of everything else, there are lib­rar­ies, tools and con­cepts built by the com­munity — not part of Mag­num it­self, but worth men­tion­ing nev­er­the­less. There are in­teg­ra­tions with vari­ous ex­tern­al UI toolkits, pack­aging scripts or proofs of concept for up­com­ing fea­tures.