Educators working with oF?


I’m a visiting prof at City Tech in NYC, previously was at Hunter College. I teach Physical Computing, Game Programming, and various other arts/tech/design/theory sorts of courses. I’ve also taught small courses and workshops at a bunch of different universities and institutions. I’ve never taught an oF course, but after taking a few commissions recently to create permanent oF installations, I’m more and more convinced that I would like to bring it into the classroom. As of now I’m teaching p5/js and Unity pretty exclusively (aside from the physical computing stuff, that’s all Arduino/C).

I’m curious who is teaching oF, and how that decision was made at your university/institution. Teaching C++ to artists sounds like a hell of an ordeal in some ways (setting up the compiler, getting them in a position to do the work outside of school on home computers, .h/.cpp, linking errors, etc etc). It would necessitate being an all-oF program (or mostly), I think, so that the skills get reinforced every semester. I think that’s how it works at Parsons. I was a little disappointed to see the ofSketch get dropped, as that could have been a happy medium or introduction to oF.


I’ve taught for almost 10 years using openframeworks at Parsons and now at school for poetic computation.

My experience is that the hardest parts often just involve comfort over the tooling and the small gotchas (setting a breakpoint by accident, etc) that can trip up beginners. But I think those are pretty minimal and things like the project generator help with being able to share a set of code to students and getting them up and running.

I find at the beginning it’s helpful to model behavior, for them to see you make a new project, deal with the IDE, and I try to show them what I am thinking. Simple excercises I give at the beginning involve writing your name, learning about drawing, abstracting the drawing of a letter (ie, draw a W but given an x,y,w,h) and then move on to more complicated topics. My order is:

a) drawing (we live in ofApp::draw (like p5 immediate mode)
b) functions that return numbers (ofGetElapsedTimef(), sin(), ofMap())
c) add variable to drawing (only inside draw)
d) variable in ofApp / setup
e) control structures (if, while, for)
f) of “objects” like ofPoint, ofImage, etc
g) objects generally

if it’s helpful here’s some sample code that comes out from in class:

I find the ofBook helpful esp

I think one thing we are missing a very simple API reference just for basics – the documentation page is gigantic and intimidating to beginners. I’d be happy to collaborate on a small doc with more essential api info.

cc @bakercp who uses OF alot in educational context.


Zach, thanks much for that. I have a bunch of friends in the SFPC orbit but haven’t been around there myself. I have the same sort of trajectory for P5, aside from introducing time based elements towards the end. I agree that oF is missing a ‘get up and running/learning’ style API reference. I’d be happy to help with something like that, how do we begin?


I teach a 7-week course using OF at NYU Abu Dhabi and I would tend to agree with Zach: if you stick with a very high-level/limited introduction, with one of the first weeks dedicated to explaining how OF works (folders hierarchy, libraries, where the apps folder has to live, etc.), then the students don’t usually encounter big hurdles/give up.

The thing is that most of them have already had at least one class in either p5js or processing, or some sort of intro to CS, so they’re ready to focus on the new aspects of OF, rather than be overwhelmed by everything.

As for an API reference, I use this cheatsheet (link) which bart was gracious enough to let me point to.


I teach at the Utrecht University of the Arts (HKU), in the School for Games & Interaction. We use oF in our 2nd year Interaction Design classes (and I know it’s used quite a bit at HKU within the School for Music & Technology)

By their 2nd year our students have some experience programming Python (using Processing), and C/C++ (in the Arduino environment).

We picked oF because it is such a powerful and widely applicable toolkit, nicely packaged in an fairly painless way. The way oF is set up does take care of a lot of the ugly details of working with C/C++ code: after 1 session most students manage to get a (simple) oF app running. I think that’s a testament to the hard work of the core oF developers… As Zach also mentions the documentation is a bit of an issue, but the forum helps.

The way I approach it is much like the others here: I introduce a concept, hook up my laptop to a large screen, and together we start coding, the students following along on their own laptops, and asking questions as we go. By the end we all have something working (usually in several variations), and for the next session I challenge them to expand or iterate on what we’ve covered.

C++ is a bit of a challenge, but after a couple of weeks most students feel more comfortable. (And we also have separate intro/advanced C++ courses).
At the moment we use the ‘industry standard’ tools VisualStudio/XCode, and I think they present more of a challenge than C++ itself: I think for a beginning coder there’s not enough transparency in those tools (at their level coding itself is quite enough abstraction thank you very much).
QTCreator could be an alternative, but on the other hand most examples/tutorials the students will find use one of those anyway…


I think most digital media programs introduce too many languages. There should be a plan that builds some scaffolding perhaps with an easier language like JS and then straight to oF/C++. In both programs I’ve taught in there is Max, Processing, JS, Arduino, and sometimes one or two more ready-made style environments like Unity. I’m curious about places like Parsons; is it really oF-only (for the most part)? What does the internal departmental strategy look like in this regard? I say this because I agree that what would give students trouble is xCode (or VS) rather than oF in particular, and why spend weeks dealing with that unless they continue with that tool throughout their degree? Might be cool for oF to have a committee that is oriented towards getting oF classes going in college curriculums, if that’s not already a thing.


Well, I think it depends on what your goals are - empowering creativity by focusing on a single toolkit, and going more into detail, or by introducing more tools and thereby adding to students’ creative tool set. Both are valid, and both are harmful when taken to an extreme (like my old physics teacher used to say: it’s knowing everything about almost nothing, or almost nothing about everything)

I hesitate to switch from VS/xCode to QTCreator: they do introduce a lot of complexity that may not (yet) be useful for our students, but they are industry-standard tools. Proficiency in those tools is also a valuable skill we can (should?) teach.


First off, hi everyone here! Nice to virtually meet you Edovino! I had your job last. I’m now at Goldsmiths where I run a MA in Independent Games and Playable Experience Design I created.

I also teach using OF, Unity, Arduino and p5. Here’s my personal take.

We should teach them all, including Max or Node and possibly Erlang. Why? because the world is a wild place and young devs are expected to understand a wide range of concepts and ideas. Here’s what I think we get out of introducing and building with each one.

  1. OF - you can really dive into c++ and make fast, intelligent projects. This lets students really rap their head around oop. Parents, templates, higher level architecture oh my! I use c++ to really show folks best coding practices like unit testing, functions without side effects and documentation. Also, the precompiler gives folks a sense of how the magic happens behind the scenes. I love c++, it’s like that mean kid in school that if you took the time to know, is really lovely. I’m not teaching it right now but at Goldsmiths, it’s still our favourite battle axe to teach computational arts. The only thing I have a problem with in OF is our documentation. One of my games is in OF and it takes me a week to remember stuff each time I open it. That said, the forum is grand. Encourage folks to use it often.

  2. Unity - hello composition! Let’s chat. Also, z axis, can we be friends? VR? Yes please!

  3. p5 - hello possible job on the web getting actually paid, let’s chat. P5 is great at introducing web concepts to new devs and for making games. My non-profit, Code Liberation just showed 13 new games made by 13 women at the V&A this weekend who had never coded before. It was great to see how quickly they learned the language and just how far they got in a few weeks.

  4. Arduino - you can go “there” and by there I mean you can drop down to the hex registers. Folks and really get a handle on how to make optimised code. Also, hardware gets people debugging like no other platform which is code based alone. You can have things like diodes crack at the np junction and turn magically into capacitors! This happened at Nasa once and the process it took for them to identify that one diode is a great case study to share.

I’d also say give folks max because some people are node people. That’s just how it is. Some visual people I know who are outstanding devs can only tolerate Max. I have no idea why. Ask someone who can open max without crying.

Erlang is cool. I hardly understand it but Ben Shapiro at CU uses it with great success in his courses and it’s a different way of thinking.

A diversity of approaches, tools and styles really gives you the largest possible chance people will find one that works for them and how they like to work. Also, it preps them for real life where people change platforms to suit the project.

That said, I agree it’s wise to introduce them one at a time and explain why and how they differ. I just ran a bootcamp for 2 weeks for my MA and I introduced them in this order: P5, C/Arduino and Unity. P5 and Arduino go really nicely together because they are functional. Unity gives you a chance to start talking about parents and OOP. It went well. Minds only melted once when I showed live coding in class.

Ok - this is a great thread and I’m glad to see it here.



An aside which would be cool to see develop if that happens would be finding a way to use Zach’s teaching materials as a base set of material for new teachers. They are amazing and not so known. I think Zach’s algo class which is lurking on his github has the best oF examples I have ever used for teaching. His former student, Jane Friedhoff, tipped me off to them and they blow away any other resources I have for just sheer ideas in a logical flow.


I like that list, I propose we call them The Big 4 :sunglasses: Still not sure how I feel about Max these days, but you bring up a good point that some people just jive with visual programming.

I can’t argue with the rationale y’all have brought up in favor of many vs. few offerings, but I will say that some of my students have voiced concerns over this issue. If there are 5 languages (or whatever we want to call them) being taught, in a typical Masters degree you would be lucky to have 2 classes of each (and even that feels like a stretch). So I think some people feel a little adrift afterwards: “Okay, I just sort-of learned this Max thing, and now I’m in a JS class, oh and the person who taught Max 2 is going on sabbatical.”

Also I think when you offer a diversity in tools you inherently lose diversity in programming concepts. By sticking to one language and being able to build on previous knowledge you can work in more advanced arenas. If you jump around a lot, that means learning how to iterate in JS, then Max, then C. And this is compounded by development environments; We’ve already talked about how awful it can be to work with xCode. If a program was more pared down, I could imagine being able to talk about a broad range of subjects that are just out of reach when you have to re-learn things too often.

That said, I myself am glad to have multiple tools in my set. And like Perry brought up, the real world (job market and otherwise) often demands a broad range of skills.


Hi Phoenix!

Yeah, we met reeeeeeeally quickly IRL, just before you left for Goldsmiths - I think you more or less had your boardingpass already in hand :slight_smile:

Back on topic: I’m interested in other peoples ideas about tooling - as in development tooling. I don’t think I could live with a proper commandline, but a nice IDE is indispensible. However I’m not convinced that either XCode or VS are the ideal tools for beginning programmers. Similarly, getting to grips with GIT takes up cognitive capacity that might be better spent on the toolkits themselves…

Thoughts & suggestions welcome!


+1 for thoughts on git. Students are ‘supposed to know it’ by the time they take my classes, but after a summer break and whatnot, things are forgotten. And I personally don’t like using git from the command line either so I can’t be too annoyed.

Did any of you play around with ofSketch? It was basically a Processing-like IDE for oF. I don’t think it works anymore, though. A streamlined C++ compiler/IDE made for artists working with oF would be amazing.

Another side-curiosity: How many of you have admin privileges at your universities? Not being able to update or install software in the classroom is a major bummer.


Hi all, I’m @bakercp and I’ve been teaching OF at SAIC in the Art and Technology Studies Department (aka ATS) for about 6 years (example courses that include OF are here, here and here).

Regarding which language(s) to teach …

I always do a survey (and in class demos) of all types of “creative code” languages in any intro context for example graphical (e.g. max/pd/td/vvvv), non-graphical/procedural (processing/p5/libcinder/OF) and hybrid (Unity/Unreal). We discuss advantages and disadvantages of each from a technical, user experience, and documentation perspective. We talk about what is easy to do and what is hard (or impossible) to do with each option. But ultimately I remind people that if you are just entering the world of coding, start with the language that those closest in physical proximity are using. Simply put, start with the language most of your friends are using. Don’t fret about choosing the “best” language. The “best” language / framework is the one that allows you to express your ideas in code, in YOUR community.

We teach many languages in ATS and it really depends on the class / teacher / topic. Our physical computing courses use C++/Arduino, one of our Object-Oriented / Algorithms courses used Processing/P5 our Interactive Arts and Computer Vision courses use OF, our sound art courses tend to use Max / PD, and VR courses use Unity and more recently Unreal. Other one-off courses like a mobile-app development course used Objective-C.

I am not convinced that teaching all of these languages is the best way to develop expert coders, but we have an open curriculum at SAIC so it is very difficult to enforce prerequisites. Students that want to become “expert” coders as undergraduates are usually highly self-motivated and will learn whatever they need to learn to express their ideas. I actively support these students outside of class.

For some courses like my graduate intro, we use Arduino/C++ and openFrameworks/C++ because I structure my course to show how you can express the same ideas in two languages in similar ways (e.g. making lights blink on an Arduino is very similar to making “lights/filled circles” blink in openFrameworks). I’ll often cut and paste code from one to the other.

Regarding IDEs, Xcode, etc …

In terms of teaching openFrameworks, I’ve mostly gotten past the obnoxious Xcode IDE problems. Basically if you remind people over and over and over again to “Make sure you set the correct build target” and “Make sure you don’t accidentally set a breakpoint” and “if your project doesn’t work and you get red / missing files, just regenerate your project files” you will solve 99% of non-code issues.

Regarding ofSketch …

Incidentally, I wrote ofSketch with @brannondorsey a few years back as an experiment and we suspended development primarily because we were simply outgrowing it too quickly in semester-long courses and the transition to Xcode after ofSketch was taking more time than it was worth. It was a super great way to demonstrate concepts and get simple stuff going, but most students chose to use openFrameworks because they wanted to do cross-platform stuff (ios, etc) which necessitates Xcode (currently). We decided that if we did want to keep developing Xcode, we’d need to essentially end up just making another IDE with less features.

That said, it was really really nice to use to demonstrate simple principles and make early projects. In our one-day ofSketch workshops, we had people across platforms making oF sketches as quickly as they might get up and running in Processing, which is pretty great. But for a one-day workshop, P5 or Processing may be the way to go if you are just introducing people to creative code.

Anyway, I still want something like ofSketch for students to really focus in on simple tasks and close the write / compile / run loop using actual C++ syntax (e.g. I love @danomatika’s ofxLua, etc, but I don’t want to teach another language). The other day I experimented with integrating cling, a C++ JIT compiler, into ofSketch and the results were very promising. This additional real-time feedback feature would actually give ofSketch a purpose other than just trying to make a simpler IDE. Especially with the long compile times on OF these days, a REPL compiler with real C++ syntax could be very useful. Anyway, I’m thinking in that direction now and may work on it for the next round of courses I teach at the beginning of next Summer.

So, speaking of teaching, I have to get back to … ofRotateZDeg() is up next!

Thanks for starting up this conversation!


I can see that, although for anyone whose used something like Javascript, the paradigms are easy to understand. I never really intended for ofxLua to be a teaching environment, but it certainly can be.

My OF lua interpreter loaf uses ofxLua internally and I’m using it now for both my own work and a couple production projects at work for an exhibition which opens in a few weeks. I’d say it’s working well and the development time without the compile loop is great at the expense of needing to know the OF API well beforehand and the usual cryptic scripting language runtime errors. It could be a teaching tool, but it would mainly need good API documentation for the bindings … and OF is still missing documentation for it C++ API as it is.


As a followup, I taught a medium-level course while a visiting prof at the University of Denver using OF: Creative Coding

The prerequisite class was our Processing intro and/or equivalent for CS students. This was a mixed bag as it meant the art students had a good understanding of event loop-based interaction concepts but less code background while the CS students had not done any graphics/interaction but had good coding skills. I worked to facilitate cross-learning in these cases but always had to blitz through some recap for some students. (BOOORING)

This is in the quarter system which means classes are 10 weeks long which, in some ways, is perhaps too short but always relies on a relentless schedule. It helped to structure things in way to where they could work on their projects in class time so we could fix problems and IDE usage questions together, otherwise too much time between classes can be wasted on errors instead of development.

As others have mentioned, Xcode etc can be a problem, but with 10 weeks I was able to simply tell them “yeah this is not easy, but it’s also not hard.” Repetition over usage, explaining compiler errors (“unknown symbol ‘foo’ means the compiler…”), learning some Google-fu and OF forum-fu helps in this regard. Of course you need fearless students, but I think a lot of that fear can be dispelled if approached in a good way (things are sometimes not easy, we can work through the details).

I have an engineering background so I prefer not to sugarcoat details or lie and say everything is “easy”. I’ve found that explaining lower level stuff when asked actually works pretty well in the long run. That’s not to be said I want to cover the CS basics when doing OF, but you have to admit there are times when you need to dig into it when using C++ and I have found it valuable to do so now and then (pointers!).


I may have a minority opinion here but I think there are about a half dozen gotchas (accidentally setting a breakpoint! etc) in xcode that once you help students get past, it’s not that bad and I use it with beginners often at SFPC. certainly, and while it’s not perfect, the PG alleviates some of the major pain points like making a new project or updating / adding addons.

certain things are helpful, I find it’s useful for intermediate students to have a simple OF class template in the new file section in xcode with a stubbed out class (one that includes ofMain and has a setup / update / draw) since the templates are not OF friendly. happy to share that…

I am quite interested in repl and I spent some time digging into cling / clang before – it was amazing to see repl like behaviour and there are maybe some changes to OF (for that I had to compile OF as a dylib) that can be helpful to make it lighter / easier to integrate into such system. I find these kinds of things great to build but they can also be a time-suck so I get a little worried – I generally feel more than tools we need a solid, beginner friendly set of docs (a tiny subset of the over all docs) that make it easier to look things up and not intimidating, ala p5 (as well as more complete documentation generally).


I’m not sure if it’s helpful, but I show people how to use atom. You lose code hinting but man - it is way nicer to work in. Once you get going, you’re functions and vars will autocomplete just like sublime. You can just build your project using make and it’s way less stress and cleaner. I also have hacked the beezesus/feel out of Xcode to look more like sublime but that takes time. Also, keyboard shortcuts are vital in Xcode and I usually lead w/them. They have cluttered that screen up with enough UI as to be overwhelming.


We’re taught a couple of courses using oF at Aalto Media Lab. Here’s the archive from last years run: