Video created from assembling a few Processing examples plus some custom code. Code below also has a simple method to generate a background of stars not included in the video.

/**
 * Corona code adapted from the Topics/Geometry/Noise Sphere example by David Pena.
 * Planets orbiting code is by Adam Schmidt: http://www.openprocessing.org/sketch/8813
 * Comets from Ignivome, inspired by Flight404's work: http://www.openprocessing.org/sketch/40052
 */

final int MAX_OPACITY = 140;
final int MAX_TAIL_AREA = 200;

//The background image
PImage stars;

Comet[] comets = new Comet[50];
Filament[] coronaFilaments = new Filament[2000];
Planet[] planets = new Planet[25];

float sunRadius = 1;
float opac = 0;

//When exporting frames for video rendering:
boolean doRecord = false;
final int FRAMES = 5400;
int frameCount = 0;

int growCounter = 0;
boolean growUp = true;
boolean hasGrown = false;

float tailArea = 2;

void setup() {
  size(1280, 720, P3D);
  noiseDetail(3);
  populateStarBackground();

  //Create the corona filaments that radiate from the black sun
  for (int i=0; i<coronaFilaments.length; i++) {
    coronaFilaments[i] = new Filament();
  }

  //Create the comets
  for(int i = 0; i < comets.length; i++){
    comets[i] = new Comet();
  }

  //Create the planets
  for (int i = 0; i< planets.length; i++ ) {
    if (i == planets.length-1){
      planets[i] = new Planet(true);
    }else{
      planets[i] = new Planet();
    }
  }
}

void draw() {
  //Hack to stop z sorting objects behind the background bitmap:
  hint(DISABLE_DEPTH_TEST);
  background(stars);
  hint(ENABLE_DEPTH_TEST);

  pointLight(255, 255, 255, width / 2, height / 2, 0);

  //Initially corona fillaments are invisible, opacity increases during initial seconds:
  if (opac < MAX_OPACITY) {
    opac = opac + 0.3;
  }

  translate(width/2, height/2);

  rotateX(map( millis(), 0, 1000, 0, radians(12)));
  rotateY(map( millis(), 0, 1000, 0, radians(6)));
  rotateZ(map( millis(), 0, 1000, 0, radians(3)));

  //Draw black sun
  fill(0);
  noStroke();
  sphere(sunRadius);

  //Draw corona filaments
  for (int i = 0; i < coronaFilaments.length; i++) {
    coronaFilaments[i].draw();

    //Change size of filament
    if (growUp) {
      coronaFilaments[i].filamentLength = coronaFilaments[i].filamentLength - random(0, 0.0033);
    } else {
      coronaFilaments[i].filamentLength = coronaFilaments[i].filamentLength + random(0, 0.0033);
    }
  }

  //Draw planets
  for (int i = 0; i < planets.length; i++ ) {
    planets[i].draw(i);
    planets[i].update();
  }

  //Draw comets
  for(int i = 0; i < comets.length; i++){
    comets[i].draw();
  }

  breath();
  outputFrame();
}

void breath(){  
  //Increment all values until radio has reached height/5
  if (sunRadius < height/5 && !hasGrown) {
    sunRadius = sunRadius + 0.01;
  } else {
    hasGrown = true;
  }

  if(tailArea < MAX_TAIL_AREA){
     tailArea = tailArea + 0.06;
  }else if(hasGrown){
    if(growUp){
     if(tailArea < MAX_TAIL_AREA){
       tailArea = tailArea + 0.06;
     }
    }else{
     tailArea = tailArea - 0.06;
    }
  }

  if (growUp) {
    sunRadius = sunRadius + 0.1;
  } else {
    sunRadius = sunRadius - 0.1;
  }

  if (growCounter == 650) {
    growUp = !growUp;
    growCounter = 0;
  }

  if (hasGrown) {
    growCounter++;
  }
}

class Filament {

  float z = random(-sunRadius, sunRadius);
  float phi = random(TWO_PI);
  float filamentLength = random(1.15, 1);
  float theta = asin(z/sunRadius);

  void draw() {
    //float off = (noise(millis() * 0.0005, sin(phi))-0.5) * 0.3;//random movement from original sketch
    float off = 0;
    float thetaff = theta+off;
    float phff = phi+off;//offb
    float x = sunRadius * cos(theta) * cos(phi);
    float y = sunRadius * cos(theta) * sin(phi);
    float z = sunRadius * sin(theta);

    float xo = sunRadius * cos(thetaff) * cos(phff);
    float yo = sunRadius * cos(thetaff) * sin(phff);
    float zo = sunRadius * sin(thetaff);

    float xb = xo * (filamentLength);
    float yb = yo * (filamentLength * 0.4);
    float zb = zo * (filamentLength /1.2);

    beginShape(LINES);
    stroke(255, 255, 255, opac);
    vertex(x, y, z);
    stroke(255, 255, 255, 0);
    vertex(xb, yb, zb);
    endShape();
  }
}

class Planet {
  int index;
  int t;
  float xcc = 0;
  float ycc = 0;
  float zcc = 0;
  float xpos;
  float ypos;
  float zpos;
  float diameter;
  int sunypos = 500;
  int sunxpos = 500;
  float gravmax = 0.1f;
  //int curplanet;
  int num;
  int i = 1;

  Planet(){
    diameter = random(15,50);
    float x = random(-width,width);
    float y = random(-height,height);
    float z = random(1,1000);
    xpos = (int) (x*1);
    ypos = (int) (y*1);
    zpos = (int) ((z*1)-500);
    xcc = random(-2.5f,2.5f);
    ycc = random(-2.5f,2.5f);
    zcc = random(-2.5f,2.5f);
  }

  Planet(boolean centralPlanet) {
    diameter = 125;
    xpos = width/2;
    ypos = height/2;
    zpos = 0;
    xcc = 0;
    ycc = 0;
    zcc = 0;
  }

  void update() {
    for (int i = 0;i < planets.length; i++) {
      float area1 = ((((planets[i].diameter/2))*(planets[i].diameter/2)*(planets[i].diameter/2))*PI);
      float disty = (planets[i].ypos-ypos);
      float distx = (planets[i].xpos-xpos);
      float distz = (planets[i].zpos-zpos);
      float distfull = sqrt((distz*distz)+(distx*distx+disty*disty));
      if (distfull < (planets[i].diameter/2)){
          continue;
      }
      float acc = (.008f) *(area1/(distfull*distfull));

      zcc = zcc +  (acc*distz/distfull);
      xcc = xcc +  (acc*distx/distfull);
      ycc = ycc +  (acc*disty/distfull);
    }

    zpos = zpos + zcc;
    xpos = xpos + xcc;
    ypos = ypos + ycc;
  }

  void draw(int index) {
    this.index = index;
    t = index+1;
    stroke(0);

    fill(opac/2.5, opac/2.5, opac/2.5);
    noStroke();
    specular(255, 255, 255);
    lightSpecular(255, 255, 255);
    shininess(5.0);

    pushMatrix();
      translate(xpos, ypos, zpos);
      sphere(diameter);
    popMatrix();
  }
}

class Comet {
  PVector pos;
  PVector tail[];
  int tailPosIndex;
  int tailLength;

  float psize;

  float inc1, inc2, inc3;
  float inc1Increment = random(0.01, 0.05);
  float inc2Increment = random(0.01, 0.05);
  float inc3Increment = random(0.01, 0.05);

  Comet() {
    pos = new PVector(0, 0, 0);
    psize = random(0.1, 2.0);

    tailPosIndex = 0;
    tailLength = int(psize * 50);
    tail = new PVector[tailLength];

    inc1 = random(TWO_PI);   
    inc2 = random(TWO_PI);
    inc3 = random(TWO_PI);
 }

  void draw() {
    updatePosition();
    drawTail();
  }

  void updatePosition() {
    inc1 += inc1Increment;
    inc2 += inc2Increment;
    inc3 += inc3Increment;

    pos.x = sin(inc1) * tailArea;
    pos.y = cos(inc2) * tailArea;
    pos.z = sin(inc3) * tailArea;
    tail[tailPosIndex] = new PVector(pos.x, pos.y, pos.z);
  }

  void drawTail() {
    float xp, yp, zp;
    float xOff, yOff, zOff;
    int nullPos = 0;   
    noStroke();
    beginShape(QUAD_STRIP);
    for (int i = 0; i < tailLength; i++) {
      int index = (i + tailPosIndex + 1) % tailLength;
      if ( i < tailLength - 1 && tail[index] != null) {
        float per = (i - nullPos) / float(tailLength - nullPos);
        xp = tail[index].x;
        yp = tail[index].y;
        zp = tail[index].z;
        int nextIndex = (i + tailPosIndex + 2) % tailLength;
        PVector v0 = PVector.sub(tail[index], tail[nextIndex]);
        PVector v1 = v0.cross(new PVector(0, 1, 0));
        v1.normalize();
        PVector v2 = v0.cross(v1);
        v2.normalize();
        v1 = v0.cross(v2);
        v1.normalize();
        xOff = v1.x * psize * per;
        yOff = v1.y * psize * per;
        zOff = v1.z * psize * per;

        fill(255, (255 * per)/4);

        vertex(xp - xOff, yp - yOff, zp - zOff);
        vertex(xp + xOff, yp + yOff, zp + zOff);
      }
      else nullPos++;
    }
    endShape();

    tailPosIndex++;
    tailPosIndex %= tailLength;
  }
}

void populateStarBackground(){
  stars = createImage(width, height, RGB);
  stars.loadPixels();
  for(int i = 0 ; i < 1500; i++){
    int brightness = (int)random(0, 155);
    stars.pixels[(int)random(0, stars.pixels.length)] = color(brightness);
  }
  stars.updatePixels();
}

void outputFrame(){
  if(!doRecord){
    return;
  }
  if (frameCount < FRAMES) {
    saveFrame("orbit-######.png");
    frameCount++;
  } else {
      println("Finished");
      exit();
  }
}

//If not saving frames for video rendering then allow click to save screenshot
void mousePressed(){
  if(!doRecord){
     saveFrame("screenshot.png");
     println("screenshot saved");
  }
}