The fol­low­ing pages pro­vide a high-lev­el over­view of the fea­ture set of­fered by Mag­num. For greater de­tail please read doc­u­men­ta­tion linked from the sec­tions be­low. You can al­so click on var­i­ous parts of the ar­chi­tec­ture di­a­gram.

Our “Zen Gar­den” phi­los­o­phy

  • Con­sis­tent cod­ing, build­ing, test­ing and de­ploy­ing ex­pe­ri­ence across all plat­forms
  • Light­weight core with mod­u­lar and ex­ten­si­ble ad­dons that en­able di­verse use cas­es
  • Clean code with high test cov­er­age, built and test­ed at least once a week on all plat­forms to en­sure con­tin­u­ous re­li­a­bil­i­ty and sta­bil­i­ty
  • Ac­tive­ly main­tained ex­ten­sive doc­u­men­ta­tion
  • First-class sup­port and friend­ly com­mu­ni­ty (Git­ter chat, mail­ing list)
  • Pre­mi­um sup­port and con­sult­ing of­fers (see the Pre­mi­um Ser­vices page for de­tails)

Sup­port­ed plat­forms

  • Lin­ux and em­bed­ded Lin­ux
  • Win­dows with both MSVC and MinGW, Win­dows RT (Store/Phone)
  • mac­OS, iOS
  • An­droid
  • Web (We­bAssem­bly or asm.js), through Em­scripten

Plat­form ab­strac­tion

Cor­rade is a stand­alone li­brary that forms the base de­pen­den­cy for Mag­num. In its min­i­mal form it pro­vides plat­form ab­strac­tion and low-lev­el util­i­ties that are not di­rect­ly re­lat­ed to graph­ics. See the Cor­rade project page for de­tails.

Low-lev­el util­i­ties

Set of con­ve­nience class­es and func­tions to make writ­ing of com­mand-line ap­pli­ca­tions ac­tu­al­ly en­joy­able; with min­i­mal dif­fer­ences across var­i­ous desk­top, mo­bile and web plat­forms.

  • OS, filesys­tem and ter­mi­nal en­vi­ron­ment ac­cess with con­sis­tent UTF-8 en­cod­ing across all plat­forms
  • Col­ored out­put that prints to con­sole on desk­top and iOS, brows­er con­sole on web and log­cat on An­droid
  • String, Uni­code, hash­ing and oth­er util­i­ties

Sim­ple con­tain­ers

Da­ta struc­ture im­ple­men­ta­tions that have no di­rect equiv­a­lent in the STL or are bet­ter tai­lored to spe­cif­ic use cas­es than equiv­a­lent gen­er­al stan­dard im­ple­men­ta­tions. Some are present sim­ply to bridge dif­fer­ences be­tween C++11, C++14 and C++17.

  • Light­weight C ar­ray wrap­pers with abil­i­ty to con­trol item ini­tial­iza­tion
  • Non-own­ing ar­ray views with util­i­ties for ar­ray slic­ing and cast­ing
  • Type-safe bit­fields, in­tru­sive list and more

Core API

The base Mag­num li­brary con­tains the min­i­mal set of APIs for graph­ics de­vel­op­ment. Apart from Cor­rade it has no ex­ter­nal de­pen­den­cies to make port­ing to new plat­forms as fric­tion­less as pos­si­ble.

Math li­brary

De­signed pri­mar­i­ly for graph­ics with em­pha­sis on im­ple­men­ta­tion sim­plic­i­ty and de­bug per­for­mance. Pro­vides vec­tor and ma­trix op­er­a­tions, com­plex num­bers, quater­nions and their du­al coun­ter­parts. In­tu­itive trans­for­ma­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, sRGB, HSV and XYZ col­orspace sup­port
  • Dis­tance and in­ter­sec­tion cal­cu­la­tion, ma­trix de­com­po­si­tion al­go­rithms

Ex­tra Func­tion­al­i­ty »

While you can stay with just the core Mag­num li­brary, there are ad­di­tion­al opt-in li­braries and tools pro­vid­ing fea­tures that can make de­vel­op­ment of your ap­pli­ca­tion eas­i­er. OpenGL and Vulkan wrap­per lay­er, APIs for as­set man­age­ment, mesh, tex­ture and shad­er tools, de­bug­ging and pro­to­typ­ing util­i­ties, com­mand-line util­i­ties and much more.

Plug­ins & Ex­ten­sions »

The li­braries are ex­ten­si­ble via plug­ins for as­set load­ing and con­ver­sion or, for ex­am­ple, text ren­der­ing. Mag­num pro­vides a rich set of plug­ins for load­ing com­mon im­age and scene for­mats, au­dio for­mats and im­age for­mat con­ver­sion. It’s al­so pos­si­ble to in­te­grate math li­brary of your choice for seam­less use with core Mag­num APIs.

Com­mu­ni­ty Con­tri­bu­tions »

On top of ev­ery­thing else, there are li­braries, tools and con­cepts built by the com­mu­ni­ty — not part of Mag­num it­self, but worth men­tion­ing nev­er­the­less. There are in­te­gra­tions with var­i­ous ex­ter­nal UI tool­kits, pack­ag­ing scripts or proofs of con­cept for up­com­ing fea­tures.