Below are tasks that are a great starting point for anyone interested in contributing to BRL-CAD. Most tasks can be completed in just a couple hours! No prior experience with BRL-CAD is required.

Some tasks may take longer if you aren't set up or haven't done that type before, but all they all require about the same amount of experienced effort. Each task has a description, references, and list of files you'll probably need. Can we make it any easier? Let us know.

Get Set Up

We suggest you compile BRL-CAD yourself or, if you have trouble with that, there's a virtual image with everything preconfigured, ready to go:

  1. Download our BRL-CAD Virtual Machine (VM) disk image.
  2. Install VirtualBox.
  3. Import the disk image, start the VM, and log in (password is "Brlcad!" without quotes).
  4. Run "svn up brlcad-svn-trunk" and compile.

Pick a Task

Once set up, select any task that sounds interesting, read the references, and talk with us for help. Don't worry if some words are confusing. You got this. All tasks can be completed by anyone but are grouped into the following five interest categories:

  • Code (programming)
  • Documentation and Training (technical writing)
  • Outreach and Research (graphics, marketing)
  • Quality Assurance (testing)
  • User Interface (usability, design)



Tasks related to writing or refactoring code

See the When You're Done section above for details on submitting your changes.

Close MGED only when both windows are closed

BRL-CAD has an interactive geometry editor called MGED. It's often the starting point for beginners and allows creation and manipulation of models using commands. When mged is run, it creates 2 windows: a text console for commands and an interactive graphics window. Currently, if you close the graphics window, it quits the application.

This task involves change behavior so that MGED exits only after closing both windows. Closing just the graphics window or text console should not quit MGED.


  • src/mged/mged.c
  • src/tclscripts/mged/openw.tcl
  • src/tclscripts/mged/bindings.tcl


Implement a primitive centroid function

BRL-CAD provides more than two dozen types of geometry "primitives" such as ellipsoids, boxes, and cones. Every primitive is described by a collection of callback functions, for example rt_ell_bbox() returns the bounding box dimensions for an ellipsoid. Wikipedia, Wolfram Mathworld, and various other math sites (and research papers) around the web include the equations for most of our basic primitives while others are more tricky to compute.

This task involves writing a new callback function that takes an rt_db_internal object and calculates its centroid (as a point_t 3D point). There are numerous examples in our code where we compute centroids for other primitives. The primitives that do not already have a centroid callback are itemized in following.



  • src/librt/primitives/table.c
  • src/librt/primitives/[PRIMITIVE]/[PRIMITIVE].c


Implement a primitive curvature function

BRL-CAD provides more than two dozen types of geometry "primitives" such as ellipsoids, boxes, and cones each described by a collection of callback functions, for example rt_sph_bbox() returns the bounding box dimensions for a sphere. Wikipedia, Wolfram Mathworld, and various other math sites (and research papers) around the web include the equations for most of our basic primitives while others are a little more tricky to compute.

This task involves writing the callback function rt_xxx_curve() that computes the curvature at a given point on the surface of a primitive such as;

  • superell
  • cline
  • extrude
  • grip
  • metaball
  • hrt.

There are numerous examples in our code where we compute the curvature for other primitives like the ellipsoid, sphere, elliptical parabola, etc.



  • src/librt/primitives/table.c
  • src/librt/primitives/[PRIMITIVE]/[PRIMITIVE].c


Implement a primitive UV-mapping callback

BRL-CAD provides more than two dozen types of geometry "primitives" such as ellipsoids, boxes, and cones. Every primitive is described by a collection of callback functions, for example rt_ell_bbox() returns the bounding box dimensions for an ellipsoid. One of those functions describes a UV mapping of the object's surface, which is used for things like texture and bump mapping. An example of this is rt_ell_uv() in the src/librt/primitives/ell/ell.c source file for an ellipsoid. Several of our more complex primitive types (such as BoT, NMG, and BREP/NURBS) do not presently implement a UV-mapping function leading to unexpected runtime behavior.

This task involves implementing a UV-mapping callback for any of the primitives that do not already have a functional UV-callback defined. Note that this is an advanced task that might take you more than a couple hours if you don't have solid coding skills, but it's ultimately just a few lines of code. See other primitives that already implement a UV-mapping callback for reference.



  • src/librt/primitives/extrude/extrude.c
  • src/librt/primitives/table.c
  • include/rtgeom.h


Fix elliptical torus triangulation

BRL-CAD has many 3D object types, one of them being an "Elliptical Torus". If you create a new MGED database and run this sequence of commands, it'll crash due to excessive recursion:

make eto eto
tol norm 1
facetize eto

This task's goal is to reproduce, identify, and fix the bug so that detailed eto tessellation completes successfully. To get started, see the rt_eto_tess() function in src/librt/primitives/eto/eto.c and the facetize command logic in libged.


  • src/librt/primitives/eto/eto.c, <- you'll probably need to modify this file
  • src/libged/facetize/facetize.cpp


Implement a function that evaluates volume with spherical sampling

Implement this function:

   int estimate_volume(struct db_i *dbip, 
                       struct directory *dp,
                       size_t min_samples,
                       double confidence);

For this function, you'll want to read up on some of BRL-CAD's basic data structures by looking at headers in the include/rt directory or by reading our API documentation. Calling rt_db_internal() and rt_bound_internal() will get you the bounding box around geometry from which you can calculate a bounding sphere. Once you have the bounding sphere, randomly generate a set of min_samples*2 points on the surface of the sphere. Shoot a ray through those points using rt_shootray(), as in the ray tracing example. Keep track of a volume estimate and keep shooting sets of min_samples rays until the estimate is less than the specified confidence value. Volume of a sphere is (4/3 * pi * r^3) so dividing that by num_samples will give a per-ray factor and multiplying all hit thicknesses by that factor will give a running volume estimate.



Implement a function to return an object's color

CAD geometry can have colors specified in a number of ways including directly on that object, in a parent object, and in a lookup table. For this task, you're going to implement a function that reports the color of an object given a path to that object:

   int get_color(struct db_i *dbip, const char *path, struct bu_color *rgb);

You'll need to iteratively consider each object named on the specified path (e.g., "/car/wheel/tire.r/torus") starting with "car" and working your down the path (i.e., 'wheel', 'tire.r', and then 'torus') to 1) see if a color is set on that object and 2) see if that color overrides lower-level colors (i.e., is inherited down the path), and 3) if it's a region object, whether there is a color set in the region table. You'll need to db_lookup() each object on the path to get access to its data.

For this function, you'll want to read up on some of BRL-CAD's basic data structures by looking at headers in the include/rt directory or by reading our API documentation. This task may seem complicated if you're not familiar with C/C++ APIs, data structures, or hierarchical paths, so don't be shy asking questions.


Code References:

  • src/libged/display_list.c
  • src/libged/color/color.c
  • src/librt/prep.c


Stub in an OpenVDB object

BRL-CAD has dozens of distinct primitive object types. For this task, you're going to implement the bare minimum to necessary to create a new object with the "make" command in MGED.

The best way to achieve this task is by searching for a keyword for another primitive (e.g., 'grep -r -i superell .') and implementing your new object the same way. Start with the 'make' command itself in src/libged/make/make.c and add "vdb" alongside where you find one of the other primitive types (e.g., superell). To get that to compile, you'll have to add new symbols you've defined into header files (e.g., include/rt/rtgeom.h). You'll eventually need to implement barebones logic in src/librt/primitives/vdb too.


  • include/rt/defines.h <- needs an ID
  • include/rt/geom.h <- needs an "internal" i.e., in-memory structure
  • src/libged/make/make.c <- needs to recognize "vdb" as a valid type
  • src/librt/primitives/table.cpp <- needs an entry
  • src/librt/primtiives/vdb <- needs a dir
  • src/librt/primitives/vdb/vdb.c <- needs _import5/_export5 callbacks, maybe _describe too


Documentation and Training

Tasks related to creating/editing documents and helping others learn more about BRL-CAD

Add missing documentation (for any ONE command)

BRL-CAD is an extensive system with more than 400 commands and more than a million pages of documentation, but there are approximately 120 commands that are entirely undocumented:

a-d archer asc2g asc2pix bot-bldxf bottest brep_cube brep_simple brickwall btclsh burst bw-a bw-d bwish c-d chan_add clutter contours d-a damdf dauto dauto2 d-bw dconv ddisp d-f dfft d-i dmod double-asc dpeak dsel dsp_add dstat d-u dwin euclid_format euclid_unformat fbgammamod f-d fence fhor f-i g-adrt g-euclid1 g-jack globe g-off i-a i-d i-f ihist imod istat jack-g kurt lowp molecule nmgmodel nmg-sgp off-g pipe pipetest pix2g pix3filter pixcount pixelswap pixembed pixfields pixfieldsep pixflip-fb pixpaste pix-spm pix-yuv plstat pyramid rawbot remapid rlesortmap rletovcr room rtcell rtexample rtfrac rtrad rtsil rtsrv script-tab sketch solshoot sphflake spltest spm-fb ssampview syn tea tea_nmg testfree texturescale torii ttcp tube txyz-pl u-a u-bw u-d u-f umod ustat vcrtorle vegitation wall wdb_example xbmtorle xyz-pl yuv-pix

This task involves writing basic documentation for JUST ONE of those commands in the Docbook XML format. The command documentation should provide a one-sentence description, a detailed paragraph description (200+ words), explanation of all available command-line options, and one or more examples on how to use the command.


  • doc/docbook/system/man1/en/
  • doc/docbook/system/man1/en/*.xml


Complete our "Intro to BRL-CAD Modeling" tutorial and extend it

We've developed two short and simple tutorials for introducing new users to modeling with BRL-CAD.

This task involves doing one of the tutorials (they take about an hour) and then extending it with a new section or making some other improvement. At the end of the tutorial are several optional advanced "exercise left to the reader", for example. Write a half-page step-by-step for one of the exercises left to the reader. Include screenshots and images to make it look nice so the reader is not bored.



Translate "Contributors Guide To BRL-CAD" To Any Language

People interested in improving BRL-CAD sometimes find themselves lost in a sea of information. In all, BRL-CAD has more than a million words of documentation across hundreds of manual pages, dozens of tutorials and examples, hundreds of wiki pages, dozens of technical papers, and other resources. There are literally thousands of features and this can sometimes pose problems.

In 2013, a team of contributors got to California and worked on an entire book titled "Contributors Guide To BRL-CAD" in just a few days. This great resource needs to be translated to other languages to attract developers from other lingual backgrounds (who don't read English ) to contribute to BRL-CAD.

This task involves translating the chapters/sections of the "Contributors Guide To BRL-CAD" into a language of your choice such as Mandarin, French, Chinese, Spanish, German, Hindi, Arabic, Russian, etc. Chapters/Sections include

  • Feature Overview
  • Working with our Code
  • What code to work on
  • How to contribute
  • .... (Just to name a few )

The output of this task can be a pdf, html, doc, odt or any other document file that contains the translated article.Images in the original document (see link in Reference below) should not be changed ! only text should be.



Write a "BRL-CAD Commands Quick Reference" document

There is already a command quick reference for BRL-CAD's MGED geometry editing tool, but there is not a similar document for BRL-CAD's 400+ command-line commands.

This task involves writing a quick reference document similar to the MGED quick reference but for BRL-CAD commands. The sheet should minimally include the following commands:

mged, rt*, *-g, g-*, fb*, *fb, nirt, remrt, rtsrv, asc2g, g2asc, dbupgrade, pix*, *pix, *-*, brlman, benchmark



Doxygen cleanup

BRL-CAD uses Doxygen for most API documentation but the comment blocks are not optimally set up for Doxygen output.

This task involves cleaning up the Doxygen comments in the library so that useful reports and API documentation automatically generated (correctly, completely, and cleanly). Verify/fix any Doxygen syntax. Verify/fix groups so that functions are organized neatly and all contained within a group. Provide patches that give clean (PDF) output from Doxygen.



... doxygen cleanup for LIBBU

There are approximately 300 documented API function calls in LIBBU.


  • include/bu.h
  • src/libbu
  • misc/Doxyfile



... doxygen cleanup for LIBWDB

There are approximately 100 documented API function calls in LIBWDB.


  • include/wdb.h
  • include/raytrace.h
  • src/libwdb
  • misc/Doxyfile



... doxygen cleanup for LIBRT

There are approximately 1000 documented API function calls in LIBRT.


  • include/raytrace.h
  • src/librt
  • src/librt/primitives
  • src/librt/comb
  • src/librt/binunif
  • misc/Doxyfile




Add images to our wiki page on Volumetric objects

BRL-CAD provides a couple dozen distinct primitives. Each primitive is defined by a set of parameters. Several of the more complex primitives have a wiki page describing them in more detail with an example on how to create them.

This task involves adding images to our page for the VOL primitive. You'll need to first complete the tutorial and save images for each step. Add the images to the wiki page.



Fix Image Formatting in BRL-CAD's DocBook Documentation (any ONE large document or 4 smaller documents)

The majority of BRL-CAD's documentation is defined as DocBook files, from which other formats (HTML, PDF, man page, etc.) can be generated. PDF files present a particular challenge, and have some very specific requirements to achieve "good" formatting.

BRL-CAD's DocBook files need to uniformly use a style of image inclusion that is aware of what "role" the image is supposed to serve. A "basic" image inclusion example looks like this:



       Caption goes here.

This task involves switching image inclusions that use the above style to something like the following:




       Caption goes here.

The "role" flag to imageobject provides the opportunity to specify different image formatting options when the output is HTML (role="html") or PDF (role="fo").

The captions should be preserved as above on mediaobjects that have them, but mediaobjects without a caption should also be converted and there is no need to add a caption in such cases.

Any patch that makes changes to the DocBook sources should result in a successful "make doc" build test. This won't generate PDF documents, but it will validate the XML files and produce HTML - remember that introducing breakage means the patch won't be accepted.

Remember, the tasks are simply to do the above conversion for all images in the file or files, not to introduce PDF specific formatting. Formatting fixes will be needed, but they are very much "case by case" and will take both additional time and a working Apache FOP installation, as well as knowledge of how to enable PDF generation. If all image inclusions have been converted successfully and a student is interested in actually fixing the formatting, please discuss it with us on IRC or the mailing list.


  • doc/docbook/books/en/BRL-CAD_Tutorial_Series-VolumeIII.xml


  • doc/docbook


Find 5 bugs in OGV

Online Geometry Viewer is a web based application with which you can see 3D .g models in browser without the use of any plugins. Your task will be to deploy OGV locally and find 5 bugs or errors in it.



Outreach and Research

Tasks related to community management, outreach/marketing, studying problems, and recommending solutions

Profile NURBS prep performance

BRL-CAD implements support for rendering of NURBS representation geometry. If you import a solid 3DM or STEP format model into BRL-CAD, it will import as BREP/NURBS geometry. Opening that geometry in BRL-CAD's MGED editor will tell you what objects are available and our 'rt' tool will raytrace it. When geometry is ray traced, it first goes through a "prep" phase and then it starts shooting rays. Our prep phase is entirely unoptimized so we'd like to know where all the time is presently being spent during prep..

This task involves importing some NURBS geometry into BRL-CAD and ray tracing that geometry with a profiler watching our prep performance. Any profiler will do, including gprof, but a performance monitor like oprofile or the Mac "Instruments" application (or Shark) are preferred.

Learning how to use a profiler is beyond the scope of this task, so it make take you considerably longer to provide us with useful information if you've never run a profiler before.

To capture prep performance, you will need to import some fairly complex geometry. You should be able to search google with "filetype:3dm" or "filetype:step" or find something on to import

Running "tops" within mged will tell you what geometry is available for rendering.

Running "rt -o file.png -s32" on the system command line (not inside mged) should minimize the ray overhead or you can specifically isolate the prep phase we care about. Prep is the time between when rt is run where it opens a window until the first pixels are fired and pixels start filling in.


Continue investigating GMP integration

BRL-CAD uses a fastf_t typedef for most all math operations that is usually a "double" floating point type. We would like to provide the option for resorting to exact arithmetic if possible by merely redefining fastf_t to a C++ type sufficiently overloaded to behave the same. You should be proficient with C++ operator overloading to take this work on. This task is a continuation of a prior GCI task (read it in full!):

This task involves testing compilation with a C++ class with overloaded operators such that vmath macro calls still work as well as a sampling of LIBBN API function calls without major changes to the original code. A perfect example case study would be creating the class then testing whether bn_dist_pt3_pt3() and bn_mat_determinant() compute correctly for values that cannot be exactly represented with floating point arithmetic.

Building on the previous GCI task work, take it to the next step. Try setting a vector to 1/3, 1/3, 1/3 and 0.1, 0.1, 0.1 and get proper values to print. Change the V3ARGS() macro if needed. If that all works, try to get bn_dist_pt3_pt3() to work. Report and discuss your progress.


Upgrade OpenNURBS, report issues

BRL-CAD uses a customized OpenNURBS library for advanced geometry but it's out of date. For this task, you're going to download the latest OpenNURBS code and upgrade the sources we bundle. The easiest way is probably to move src/other/openNURBS to src/other/openNURBS.backup, and then put the latest OpenNURBS release into src/other/openNURBS.

Once that's done, you'll need to add the src/other/openNURBS.backup/CMakeLists.txt file and make sure the list of files it has matches the files in src/other/openNURBS. Last but not least, re-run cmake and make sure it compiles. You may need to consult the newer openNURBS makefile to see if there are other edits needed in the CMakeLists.txt file.

Save output from any commands you run because you'll probably encounter an error, and that's okay. Just submit logs of all output so we can figure out next steps.



  • src/other/openNURBS <- replace existing with latest openNURBS from github


Design a T-Shirt for BRL-CAD

This task involves designing a T-Shirt for BRL-CAD. Use your designing skills to design a T-Shirt for BRL-CAD. You can use the current BRL-CAD logo, or you may tweak it. Be creative while designing this T-Shirt. It would be good if the design has some special meaning.

Logo References


Design a coffee mug for BRL-CAD

This task involves designing a coffee mug for BRL-CAD. Make it look good or at least interesting, and make it in BRL-CAD. Look over some coffee mug designs before starting to work on this. Verify that your mug is valid geometry by running the "rtcheck" command.

Logo References


Design BRL-CAD sticker

This task involves designing a BRL-CAD sticker. The design should be simple and sleek. The concept of sticker should be clear and also it should be creatively presented. Get inspired from some sticker designs but choose your own imagination while designing the sticker. There is no bound for shape of sticker, it can be rectangular, circular or even irregular. The only thing that matters is that it should look good.

Logo References


Design a wallpaper / desktop image for BRL-CAD

This task involves designing a desktop background for BRL-CAD enthusiasts. The main idea of your wallpaper should be to showcase one or more features of BRL-CAD. Be intentional and able to defend/describe your choice of color, layout, and other aspects of the wallpaper design.

Try to make sure the wallpaper works across a broad selection of screen resolutions.

Search the web for wallpapers inspiration such as:

Logo References


Model a Lightcycle in BRL-CAD using CSG

The movie Tron is an iconic computer graphics film that used CSG primitives for a majority of the movie's 3D virtual world. The film is famous for "lightcycle" vehicles that were allegedly modeled using 57 primitives and/or Boolean operations. For this task, see if you can recreate the masterpiece in BRL-CAD.

See this lightcycle discussion thread


Quality Assurance

Tasks related to testing and ensuring code is of high quality

Fix single-precision floating point crash

By default, all of BRL-CAD compiles using double-precision floating point arithmetic. We provide a simple typedef, however, that converts almost the entire system over to single-precision floating point. This compilation mode was recently cleaned up and tested, but a bug was found. The problem is reproduced very simply by compiling in single precision mode and running our "rt" ray tracer tool.

To compile in single precision, edit the include/bn.h header file and change the fastf_t typedef from double to float. To reproduce the bug, compile BRL-CAD and write this out to a text file named star.view:

viewsize 2.500000000e+05;
eye_pt 2.102677960e+05 8.455500000e+04 2.934714650e+04;
viewrot -6.733560560e-01 6.130643360e-01 4.132114880e-01 0.000000000e+00
        5.539599410e-01 4.823888300e-02 8.311441420e-01 0.000000000e+00
        4.896120540e-01 7.885590550e-01 -3.720948210e-01 0.000000000e+00
        0.000000000e+00 0.000000000e+00 0.000000000e+00 1.000000000e+00 ;
start 0;

Then run rt feeding it that view script as input. This is an example how to run within the gdb debugger:

gdb path/to/bin/rt
(gdb) run -F/dev/X -M .cmake/share/db/star.g all < star.view

At this point, rt should crash due to an infinite recursion. A backtrace in the debugger will show lots and lots of calls to rt_shootray() and light_hit().

This task involves investigating and preventing the crash. Provide a patch that fixes the bug.


  • man gdb
  • brlman rt


  • src/librt/shoot.c
  • src/liboptical/sh_light.c


Fix closedb

BRL-CAD geometry editor application (mged) has several hundred commands including two very simple commands for opening and closing a geometry database file. While the user rarely ever needs to close the file, as all changes are always immediately saved, it can be of use to scripting applications. However, at some point in the recent past, the closedb command was horked. It's undoubtedly something very simple but we haven't bothered to look due to other priorities. You can fix it. If you run these simple steps within graphical mged, you should see how commands stop working after calling closedb:

 mged> opendb test.g y
 mged> make sph sph
 mged> l sph
 mged> closedb
 mged> make sph sph
 mged> opendb test.g
 mged> l sph
 mged> exit

Provide a patch that fixes the bug or tell us which SVN revision introduced the bug. Make sure you can reproduce the bug before claiming this task, which presumes you know how to download/install BRL-CAD from a source distribution.


  • src/mged/mged.c


Create a utility library (LIBBU) API unit test

There are more than 300 library functions in our core LIBBU library. As a core library used by nearly every one of BRL-CAD's tools, testing those functions for correct behavior is important.

This task involves implementing new unit tests for any of LIBBU's source files that do not already have a unit test defined. The test should run all of the public functions and be hooked into our build system. We have lots of existing unit tests to follow as examples.


  • include/bu.h
  • src/libbu/*.c
  • src/libbu/tests/*.c


  • src/libbu/tests/[TEST].c
  • src/libbu/tests/CMakeLists.txt


Create Numerics library (LIBBN) API unit tests

There are more than 300 library functions in our core LIBBN library. As a core library used by nearly every one of BRL-CAD's tools, testing those functions for correct behavior is important.

This task involves implementing new unit tests for any of LIBBN's source files that do not already have a unit test defined. The test should run all of the public functions and be hooked into our build system. We have lots of existing unit tests to follow as examples.


  • include/bn.h
  • include/plot3.h
  • include/vmath.h
  • src/libbn/*.c
  • src/libbn/tests/*.c <-- check this directory for examples
  • src/libbu/tests/*.c <-- Note: Also check this too for more examples.


  • src/libbn/tests/[TEST].c
  • src/libbn/tests/CMakeLists.txt

Note A valid task will constitute writing a basic test for each function in the following libbn/ files.


... unit tests for LIBBN anim.c



... unit tests for LIBBN axis.c



... unit tests for LIBBN qmath.c



... unit tests for LIBBN rand.c



... unit tests for LIBBN vector.c




Find, reliably reproduce, and report any bug in Archer

Archer is our new modeling interface and a soon to merge with our long-standing MGED geometry editor. It undoubtedly has bugs. It's your job to find one, but do so in a manner that is so obvious that one of the other devs will be able to instantly reproduce the bug given your specific instructions. Find a way to make archer crash, become unresponsive, or otherwise behave incorrectly. You will have to explore the tool with minimal documentation.

This task involves filing a bug report with verifiable and reproducible steps that clearly demonstrate the bug. It can't be a bug already reported or otherwise documented nor can it be merely behavior you don't like.



Reproduce any 10 unconfirmed open bug reports

BRL-CAD presently has approximately 75 open bug reports of which 50 are unassigned. Read the comments and status to see if the bug has been confirmed/reproduced.

This task involves going through those reports and REPRODUCE at least 10 of the ones that have not been confirmed. When you can reproduce the issue being reported, you'll comment on the thread to state as much and attach any data you used to reproduce the crash.



User Interface

Tasks related to user experience research or user interface design and interaction

Create an ISST screenshot or animation

Everyone loves to see screenshots and animations of software in action. We use both in our marketing and outreach. See some of the examples below that we already have.

Create an awesome screenshot and/or animation of our 'isst' tool in action. It's an interactive geometry viewer interface. It should be graphically interesting and give some sense of capability. You should import a visually complex and interesting model with LOTS of polygons and detail. Note you may have to go through some or the MGED tutorials (see Docs on our website).



Categorize commands into a spreadsheet

BRL-CAD is a suite of more than 400 commands, processing tools, image tools, geometry converters, and more. MGED also has a command-line with hundreds of commands too. Help us reorganize one of those command sets.

This task involves creating a spreadsheet that lists all commands and groups them together into a finite set of categories or labels. This spreadsheet will help us identify places where commands can be consolidated, commands we might want to consider removing, common groupings for documentation, etc.


Design a Cover Photo for Facebook (and other social media)

BRL-CAD website and marketing materials are constantly undergoing change. Effective marketing requires well designed and attractive imagery. Imagery ideally should showcase some feature of BRL-CAD, some highlight, something visually interesting and compelling.



Create a video for BRL-CAD

Watching someone else use software is incredibly helpful to some. Create a screen-cast video for BRL-CAD that showcases some feature, goes over steps involved in creating some model, or shows how to accomplish some other task.

You'll need to install BRL-CAD on your computer and use it in the video. Create or import some model and make a recording.


When You're Done

For non-code, just send us your file(s). For code changes, you will be expected to provide a patch file. Make sure you read your patch file before submitting it. Make sure your patch file will apply cleanly to an unmodified checkout of BRL-CAD:

svn co cd brlcad.edit # make changes svn diff > ~/my.patch # read ~/my.patch file with text editor cd .. svn co cd brlcad.fresh patch -p0 < ~/my.patch # submit your patch file to our patches tracker