bufferStrategy.getCapabilities().getFrontBufferCapabilities().isAccelerated() returns true
bufferStrategy.getCapabilities().getBackBufferCapabilities().isAccelerated() returns true
bufferStrategy.getCapabilities().getFrontBufferCapabilities().isTrueVolatile() returns false
bufferStrategy.getCapabilities().getBackBufferCapabilities().isTrueVolatile() returns false

And:
GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getAvailableAcceleratedMemory() returns (more or less) 119000000

frame.setVisible(true);
frame.createBufferStrategy(2);
graphics = (Graphics2D) frame.getBufferStrategy().getDrawGraphics();

public static BufferedImage loadBufferedImage(String path) {
...
    ImageIcon i = new ImageIcon(path);
    BufferedImage bi = new BufferedImage(i.getIconWidth(), i.getIconHeight());
    bi.getImage().getGraphics().drawImage(i.getImage(), 0, 0, null); // image, width, height, image observer
    return bi;
}

public class JCanvas extends JComponent 
   [INNER CLASSES]

   private static final long serialVersionUID = 123456789L;
   private static final Dimension MINIMUM_SIZE = new Dimension(320, 200);
   
   transient ComponentPeer peer;
   private static VolatileImage vImage;
   private BufferStrategy strategy = null;
   
   public JCanvas() {
      super();
   }
      
   public void initStrategy() {
      if (this.getMinimumSize().height >= MINIMUM_SIZE.height && this.getMinimumSize().width >= MINIMUM_SIZE.width) {
         this.createBufferStrategy(2);
         this.strategy = this.getBufferStrategy();
      }
   }
   
    public BufferStrategy getBufferStrategy() {
        if (this.strategy == null) {
            createBufferStrategy(1);
        }
        return this.strategy;
    }
      
   public Graphics getBufferedGraphics() {
      return this.strategy != null ? this.strategy.getDrawGraphics() : this.getGraphics();
   }
   
   public void paintComponent(Graphics g) {
      super.paintComponent(g);
   }
   
   void createBufferStrategy(int numBuffers) {
      BufferCapabilities bufferCaps;
      if (numBuffers > 1) {
         // Try to create a page-flipping strategy
         bufferCaps = new BufferCapabilities(
                     new   ImageCapabilities(true), 
                     new ImageCapabilities(true),
                     BufferCapabilities.FlipContents.UNDEFINED);
         try {
            createBufferStrategy(numBuffers, bufferCaps);
            return;   // Success
         } catch   (AWTException e) {
            // Failed
         }
      }
      // Try a blitting (but still accelerated) strategy
      bufferCaps = new BufferCapabilities(
                  new   ImageCapabilities(true), 
                  new ImageCapabilities(true), null);
      try {
         createBufferStrategy(numBuffers, bufferCaps);
         return;   // Success
      } catch   (AWTException e) {
         // Failed
      }
      // Try an unaccelerated   blitting strategy
      bufferCaps = new BufferCapabilities(
                  new   ImageCapabilities(false), 
                  new ImageCapabilities(false), null);
      try {
         createBufferStrategy(numBuffers, bufferCaps);
         return;   // Success
      } catch   (AWTException e) {
         // Failed
      }
      // Code   should never reach here   (an   unaccelerated blitting
      // strategy   should always work)
      throw new InternalError("Could not create a   buffer strategy");
   }
   
   public void createBufferStrategy(int numBuffers, BufferCapabilities caps) 
   throws AWTException
   {
      // Check arguments
      if (numBuffers < 1) {
         throw new IllegalArgumentException("Number of buffers must be at least 1");
      }
      if (caps ==   null) {
         throw new IllegalArgumentException("No capabilities   specified");
      }
      // Destroy old buffers
      if (this.strategy instanceof FlipBufferStrategy) {
         ((FlipBufferStrategy) this.strategy).destroyBuffers();
      }
      if (numBuffers == 1) {
         this.strategy = new SingleBufferStrategy(caps);
      } else {
         // assert numBuffers > 1;
         if (caps.isPageFlipping()) {
            this.strategy = new FlipBufferStrategy(numBuffers,   caps);
         } else {
            this.strategy = new BltBufferStrategy(numBuffers, caps);
         }
      }
   }
   
   protected void destroyBuffers() {
      if (peer !=   null) {
         peer.destroyBuffers();
      } else {
         throw new IllegalStateException("Component must   have a valid peer");
      }
   }
}

...
AriesAnim walkright = new AriesAnim(AriesTools.loadImage("c:\images\walkright01.png"), AriesTools.loadImage("c:\images\walkright02.png"));
walkright.setSpeed(200);
walkright.setRepeat(true);

AriesAnim walkleft = new AriesAnim(AriesTools.loadImage("c:\images\walkleft01.png"), AriesTools.loadImage("c:\images\walkleft02.png"));
walkright.setSpeed(200);
walkright.setRepeat(true);

AriesAnim stand = new AriesAnim(AriesTools.loadImage("c:\images\stand"));

AriesAnimation walking = new AriesAnimation(4); // how many directions the character has? 4 is the minimum.
// when we add an AriesAnim to AriesAnimation we must specify the direction association, EAST for the RIGHT, WEST for the LEFT, NORTH for UP and SOUTH for DOWN, the default direction is EAST
walking.addAnim(AriesDirections.EAST, walkright);
walking.addAnim(AriesDirections.WEST, walkleft);

AriesAnimation standing = new AriesAnimation(4);
// here we associate the AriesAnim "stand" to default direction
standing.addAnim(stand);

// the final step, we create the sprite and add the animations
AriesSprite mario = new AriesSprite();
mario.addAnimation("walking", walking);
mario.addAnimation("standing", standing);
...
game.store.addObject("mario", mario);
...

public void events() {
    if (keyboard.isPressed(keyboard.KEY_RIGHT)) {
        game.store.getSprite("mario").setDirection(AriesDirections.EAST);
        game.store.getSprite("mario").setAnimation("walking").startAnimation();
    }

    if (keyboard.isPressed(keyboard.KEY_LEFT)) {
        game.store.getSprite("mario").setDirection(AriesDirections.WEST);
        game.store.getSprite("mario").setAnimation("walking").startAnimation();
    }

    // here we do not have to worry about to set the direction, because when a direction is not found the engine use the default
    if (keyboard.notTouched) {
        game.store.getSprite("mario").setAnimation("standing").startAnimation();
    }
}

// and that's all.

public class MyGame extends AriesGame {
    private AriesPicture p1 = new AriesPicture(200, 200);    

    public MyGame() {
        game = this;            // this operation is very important when you extends the class AriesGame

        game.set(AriesGame.S_640BY480, AriesGame.FULLSCREEN);    // set up the game
        p1.drawString(0, 10, "A simple java game!");        // draw a String in the AriesPicture
        p1.drawRectangle(0, 0, 199, 199, false);        // draw a Rectangle in the AriesPicture, the 'false' determines if the shape is filled or not, in this case: not.
        p1.setPosition(100, 150);        // the position on the screen
        game.store.addObject("p1", p1);        // add the object in the game
        game.start();        // start the game :)
    }

    // this method manages the events in the game and you can manage all the game by a sequence of IF-ELSE
    // if event occurs you can manage it in this simple way
    public void events() {
        // if the space bar is hit
        if (keyboard.isTyped(keyboard.KEY_SPACE)) {
            game.store.getPicture("p1").clear();        // clear the picture
            game.store.getPicture("p1").drawString(0, 10, "You hit the Space Key");        // draw a string
        }

        // if the wheel of mouse is moved up
        if (mouse.isWheelUp()) {
            game.store.getPicture("p1").move(0, -150);        // move the picture 0 pixel for X and -150 pixel for Y
        }

        // if I'm holding pressed the Shift Key and I click on the Button 1 of mouse
        if (keyboard.isPressed(keyboard.KEY_SHIFT) && mouse.isClicked(mouse.BUTTON1)) {
            game.store.getPicture("p1").move(50, 30);        // move the picture 50 pixel for X and 30 pixel for Y
        }
    }
    
    public static void main(String[] args) {
       new MyGame();
    }
}