diff --git a/dev/Gruntfile.js b/dev/Gruntfile.js
index 65ddbf4..de33a78 100644
--- a/dev/Gruntfile.js
+++ b/dev/Gruntfile.js
@@ -1,377 +1,377 @@
-// Generated on 2014-08-15 using generator-webapp 0.4.9
-'use strict';
-
-// # Globbing
-// for performance reasons we're only matching one level down:
-// 'test/spec/{,*/}*.js'
-// use this if you want to recursively match all subfolders:
-// 'test/spec/**/*.js'
-
-module.exports = function (grunt) {
-
-    // Load grunt tasks automatically
-    require('load-grunt-tasks')(grunt);
-
-    // Time how long tasks take. Can help when optimizing build times
-    require('time-grunt')(grunt);
-
-    // Configurable paths
-    var config = {
-        app: 'app',
-        dist: 'dist'
-    };
-
-    // Define the configuration for all the tasks
-    grunt.initConfig({
-
-        // Project settings
-        config: config,
-
-        // Watches files for changes and runs tasks based on the changed files
-        watch: {
-            bower: {
-                files: ['bower.json'],
-                tasks: ['bowerInstall']
-            },
-            js: {
-                files: ['<%= config.app %>/scripts/{,*/}*.js'],
-                tasks: ['jshint'],
-                options: {
-                    livereload: true
-                }
-            },
-            jstest: {
-                files: ['test/spec/{,*/}*.js'],
-                tasks: ['test:watch']
-            },
-            gruntfile: {
-                files: ['Gruntfile.js']
-            },
-            styles: {
-                files: ['<%= config.app %>/styles/{,*/}*.css'],
-                tasks: ['newer:copy:styles', 'autoprefixer']
-            },
-            livereload: {
-                options: {
-                    livereload: '<%= connect.options.livereload %>'
-                },
-                files: [
-                    '<%= config.app %>/{,*/}*.html',
-                    '.tmp/styles/{,*/}*.css',
-                    '<%= config.app %>/images/{,*/}*'
-                ]
-            }
-        },
-
-        // The actual grunt server settings
-        connect: {
-            options: {
-                port: 9000,
-                open: true,
-                livereload: 35729,
-                // Change this to '0.0.0.0' to access the server from outside
-                hostname: 'localhost'
-            },
-            livereload: {
-                options: {
-                    middleware: function(connect) {
-                        return [
-                            connect.static('.tmp'),
-                            connect().use('/bower_components', connect.static('./bower_components')),
-                            connect.static(config.app)
-                        ];
-                    }
-                }
-            },
-            test: {
-                options: {
-                    open: false,
-                    port: 9001,
-                    middleware: function(connect) {
-                        return [
-                            connect.static('.tmp'),
-                            connect.static('test'),
-                            connect().use('/bower_components', connect.static('./bower_components')),
-                            connect.static(config.app)
-                        ];
-                    }
-                }
-            },
-            dist: {
-                options: {
-                    base: '<%= config.dist %>',
-                    livereload: false
-                }
-            }
-        },
-
-        // Empties folders to start fresh
-        clean: {
-            dist: {
-                files: [{
-                    dot: true,
-                    src: [
-                        '.tmp',
-                        '<%= config.dist %>/*',
-                        '!<%= config.dist %>/.git*'
-                    ]
-                }]
-            },
-            server: '.tmp'
-        },
-
-        // Make sure code styles are up to par and there are no obvious mistakes
-        jshint: {
-            options: {
-                jshintrc: '.jshintrc',
-                reporter: require('jshint-stylish')
-            },
-            all: [
-                'Gruntfile.js',
-                '<%= config.app %>/scripts/{,*/}*.js',
-                '!<%= config.app %>/scripts/vendor/*',
-                'test/spec/{,*/}*.js'
-            ]
-        },
-
-        // Mocha testing framework configuration options
-        mocha: {
-            all: {
-                options: {
-                    run: true,
-                    urls: ['http://<%= connect.test.options.hostname %>:<%= connect.test.options.port %>/index.html']
-                }
-            }
-        },
-
-        // Add vendor prefixed styles
-        autoprefixer: {
-            options: {
-                browsers: ['last 1 version']
-            },
-            dist: {
-                files: [{
-                    expand: true,
-                    cwd: '.tmp/styles/',
-                    src: '{,*/}*.css',
-                    dest: '.tmp/styles/'
-                }]
-            }
-        },
-
-        // Automatically inject Bower components into the HTML file
-        bowerInstall: {
-            app: {
-                src: ['<%= config.app %>/index.html'],
-                exclude: ['bower_components/bootstrap/dist/js/bootstrap.js']
-            }
-        },
-
-        // Renames files for browser caching purposes
-        rev: {
-            dist: {
-                files: {
-                    src: [
-                        '<%= config.dist %>/scripts/{,*/}*.js',
-                        '<%= config.dist %>/styles/{,*/}*.css',
-                        '<%= config.dist %>/images/{,*/}*.*',
-                        '<%= config.dist %>/styles/fonts/{,*/}*.*',
-                        '<%= config.dist %>/*.{ico,png}'
-                    ]
-                }
-            }
-        },
-
-        // Reads HTML for usemin blocks to enable smart builds that automatically
-        // concat, minify and revision files. Creates configurations in memory so
-        // additional tasks can operate on them
-        useminPrepare: {
-            options: {
-                dest: '<%= config.dist %>'
-            },
-            html: '<%= config.app %>/index.html'
-        },
-
-        // Performs rewrites based on rev and the useminPrepare configuration
-        usemin: {
-            options: {
-                assetsDirs: ['<%= config.dist %>', '<%= config.dist %>/images']
-            },
-            html: ['<%= config.dist %>/{,*/}*.html'],
-            css: ['<%= config.dist %>/styles/{,*/}*.css']
-        },
-
-        // The following *-min tasks produce minified files in the dist folder
-        imagemin: {
-            dist: {
-                files: [{
-                    expand: true,
-                    cwd: '<%= config.app %>/images',
-                    src: '{,*/}*.{gif,jpeg,jpg,png}',
-                    dest: '<%= config.dist %>/images'
-                }]
-            }
-        },
-
-        svgmin: {
-            dist: {
-                files: [{
-                    expand: true,
-                    cwd: '<%= config.app %>/images',
-                    src: '{,*/}*.svg',
-                    dest: '<%= config.dist %>/images'
-                }]
-            }
-        },
-
-        htmlmin: {
-            dist: {
-                options: {
-                    collapseBooleanAttributes: true,
-                    collapseWhitespace: true,
-                    removeAttributeQuotes: true,
-                    removeCommentsFromCDATA: true,
-                    removeEmptyAttributes: true,
-                    removeOptionalTags: true,
-                    removeRedundantAttributes: true,
-                    useShortDoctype: true
-                },
-                files: [{
-                    expand: true,
-                    cwd: '<%= config.dist %>',
-                    src: '{,*/}*.html',
-                    dest: '<%= config.dist %>'
-                }]
-            }
-        },
-
-        // By default, your `index.html`'s <!-- Usemin block --> will take care of
-        // minification. These next options are pre-configured if you do not wish
-        // to use the Usemin blocks.
-        // cssmin: {
-        //     dist: {
-        //         files: {
-        //             '<%= config.dist %>/styles/main.css': [
-        //                 '.tmp/styles/{,*/}*.css',
-        //                 '<%= config.app %>/styles/{,*/}*.css'
-        //             ]
-        //         }
-        //     }
-        // },
-        // uglify: {
-        //     dist: {
-        //         files: {
-        //             '<%= config.dist %>/scripts/scripts.js': [
-        //                 '<%= config.dist %>/scripts/scripts.js'
-        //             ]
-        //         }
-        //     }
-        // },
-        // concat: {
-        //     dist: {}
-        // },
-
-        // Copies remaining files to places other tasks can use
-        copy: {
-            dist: {
-                files: [{
-                    expand: true,
-                    dot: true,
-                    cwd: '<%= config.app %>',
-                    dest: '<%= config.dist %>',
-                    src: [
-                        '*.{ico,png,txt}',
-                        '.htaccess',
-                        'images/{,*/}*.webp',
-                        '{,*/}*.html',
-                        'styles/fonts/{,*/}*.*'
-                    ]
-                }, {
-                    expand: true,
-                    dot: true,
-                    cwd: 'bower_components/bootstrap/dist',
-                    src: ['fonts/*.*'],
-                    dest: '<%= config.dist %>'
-                }]
-            },
-            styles: {
-                expand: true,
-                dot: true,
-                cwd: '<%= config.app %>/styles',
-                dest: '.tmp/styles/',
-                src: '{,*/}*.css'
-            }
-        },
-
-        // Run some tasks in parallel to speed up build process
-        concurrent: {
-            server: [
-                'copy:styles'
-            ],
-            test: [
-                'copy:styles'
-            ],
-            dist: [
-                'copy:styles',
-                'imagemin',
-                'svgmin'
-            ]
-        }
-    });
-
-
-    grunt.registerTask('serve', function (target) {
-        if (target === 'dist') {
-            return grunt.task.run(['build', 'connect:dist:keepalive']);
-        }
-
-        grunt.task.run([
-            'clean:server',
-            'concurrent:server',
-            'autoprefixer',
-            'connect:livereload',
-            'watch'
-        ]);
-    });
-
-    grunt.registerTask('server', function (target) {
-        grunt.log.warn('The `server` task has been deprecated. Use `grunt serve` to start a server.');
-        grunt.task.run([target ? ('serve:' + target) : 'serve']);
-    });
-
-    grunt.registerTask('test', function (target) {
-        if (target !== 'watch') {
-            grunt.task.run([
-                'clean:server',
-                'concurrent:test',
-                'autoprefixer'
-            ]);
-        }
-
-        grunt.task.run([
-            'connect:test',
-            'mocha'
-        ]);
-    });
-
-    grunt.registerTask('build', [
-        'clean:dist',
-        'useminPrepare:html',
-        'concurrent:dist',
-        'autoprefixer',
-        'concat',
-        'cssmin',
-        'uglify',
-        'imagemin',
-        'copy:dist',
-        'rev',
-        'usemin',
-        'htmlmin'
-    ]);
-
-    grunt.registerTask('default', [
-        'newer:jshint',
-        //'test',
-        'build'
-    ]);
-};
+// Generated on 2014-08-15 using generator-webapp 0.4.9
+'use strict';
+
+// # Globbing
+// for performance reasons we're only matching one level down:
+// 'test/spec/{,*/}*.js'
+// use this if you want to recursively match all subfolders:
+// 'test/spec/**/*.js'
+
+module.exports = function (grunt) {
+
+    // Load grunt tasks automatically
+    require('load-grunt-tasks')(grunt);
+
+    // Time how long tasks take. Can help when optimizing build times
+    require('time-grunt')(grunt);
+
+    // Configurable paths
+    var config = {
+        app: 'app',
+        dist: 'dist'
+    };
+
+    // Define the configuration for all the tasks
+    grunt.initConfig({
+
+        // Project settings
+        config: config,
+
+        // Watches files for changes and runs tasks based on the changed files
+        watch: {
+            bower: {
+                files: ['bower.json'],
+                tasks: ['bowerInstall']
+            },
+            js: {
+                files: ['<%= config.app %>/scripts/{,*/}*.js'],
+                tasks: ['jshint'],
+                options: {
+                    livereload: true
+                }
+            },
+            jstest: {
+                files: ['test/spec/{,*/}*.js'],
+                tasks: ['test:watch']
+            },
+            gruntfile: {
+                files: ['Gruntfile.js']
+            },
+            styles: {
+                files: ['<%= config.app %>/styles/{,*/}*.css'],
+                tasks: ['newer:copy:styles', 'autoprefixer']
+            },
+            livereload: {
+                options: {
+                    livereload: '<%= connect.options.livereload %>'
+                },
+                files: [
+                    '<%= config.app %>/{,*/}*.html',
+                    '.tmp/styles/{,*/}*.css',
+                    '<%= config.app %>/images/{,*/}*'
+                ]
+            }
+        },
+
+        // The actual grunt server settings
+        connect: {
+            options: {
+                port: 9000,
+                open: true,
+                livereload: 35729,
+                // Change this to '0.0.0.0' to access the server from outside
+                hostname: 'localhost'
+            },
+            livereload: {
+                options: {
+                    middleware: function(connect) {
+                        return [
+                            connect.static('.tmp'),
+                            connect().use('/bower_components', connect.static('./bower_components')),
+                            connect.static(config.app)
+                        ];
+                    }
+                }
+            },
+            test: {
+                options: {
+                    open: false,
+                    port: 9001,
+                    middleware: function(connect) {
+                        return [
+                            connect.static('.tmp'),
+                            connect.static('test'),
+                            connect().use('/bower_components', connect.static('./bower_components')),
+                            connect.static(config.app)
+                        ];
+                    }
+                }
+            },
+            dist: {
+                options: {
+                    base: '<%= config.dist %>',
+                    livereload: false
+                }
+            }
+        },
+
+        // Empties folders to start fresh
+        clean: {
+            dist: {
+                files: [{
+                    dot: true,
+                    src: [
+                        '.tmp',
+                        '<%= config.dist %>/*',
+                        '!<%= config.dist %>/.git*'
+                    ]
+                }]
+            },
+            server: '.tmp'
+        },
+
+        // Make sure code styles are up to par and there are no obvious mistakes
+        jshint: {
+            options: {
+                jshintrc: '.jshintrc',
+                reporter: require('jshint-stylish')
+            },
+            all: [
+                'Gruntfile.js',
+                '<%= config.app %>/scripts/{,*/}*.js',
+                '!<%= config.app %>/scripts/vendor/*',
+                'test/spec/{,*/}*.js'
+            ]
+        },
+
+        // Mocha testing framework configuration options
+        mocha: {
+            all: {
+                options: {
+                    run: true,
+                    urls: ['http://<%= connect.test.options.hostname %>:<%= connect.test.options.port %>/index.html']
+                }
+            }
+        },
+
+        // Add vendor prefixed styles
+        autoprefixer: {
+            options: {
+                browsers: ['last 1 version']
+            },
+            dist: {
+                files: [{
+                    expand: true,
+                    cwd: '.tmp/styles/',
+                    src: '{,*/}*.css',
+                    dest: '.tmp/styles/'
+                }]
+            }
+        },
+
+        // Automatically inject Bower components into the HTML file
+        bowerInstall: {
+            app: {
+                src: ['<%= config.app %>/index.html'],
+                exclude: ['bower_components/bootstrap/dist/js/bootstrap.js']
+            }
+        },
+
+        // Renames files for browser caching purposes
+        rev: {
+            dist: {
+                files: {
+                    src: [
+                        '<%= config.dist %>/scripts/{,*/}*.js',
+                        '<%= config.dist %>/styles/{,*/}*.css',
+                        '<%= config.dist %>/images/{,*/}*.*',
+                        '<%= config.dist %>/styles/fonts/{,*/}*.*',
+                        '<%= config.dist %>/*.{ico,png}'
+                    ]
+                }
+            }
+        },
+
+        // Reads HTML for usemin blocks to enable smart builds that automatically
+        // concat, minify and revision files. Creates configurations in memory so
+        // additional tasks can operate on them
+        useminPrepare: {
+            options: {
+                dest: '<%= config.dist %>'
+            },
+            html: '<%= config.app %>/index.html'
+        },
+
+        // Performs rewrites based on rev and the useminPrepare configuration
+        usemin: {
+            options: {
+                assetsDirs: ['<%= config.dist %>', '<%= config.dist %>/images']
+            },
+            html: ['<%= config.dist %>/{,*/}*.html'],
+            css: ['<%= config.dist %>/styles/{,*/}*.css']
+        },
+
+        // The following *-min tasks produce minified files in the dist folder
+        imagemin: {
+            dist: {
+                files: [{
+                    expand: true,
+                    cwd: '<%= config.app %>/images',
+                    src: '{,*/}*.{gif,jpeg,jpg,png}',
+                    dest: '<%= config.dist %>/images'
+                }]
+            }
+        },
+
+        svgmin: {
+            dist: {
+                files: [{
+                    expand: true,
+                    cwd: '<%= config.app %>/images',
+                    src: '{,*/}*.svg',
+                    dest: '<%= config.dist %>/images'
+                }]
+            }
+        },
+
+        htmlmin: {
+            dist: {
+                options: {
+                    collapseBooleanAttributes: true,
+                    collapseWhitespace: true,
+                    removeAttributeQuotes: true,
+                    removeCommentsFromCDATA: true,
+                    removeEmptyAttributes: true,
+                    removeOptionalTags: true,
+                    removeRedundantAttributes: true,
+                    useShortDoctype: true
+                },
+                files: [{
+                    expand: true,
+                    cwd: '<%= config.dist %>',
+                    src: '{,*/}*.html',
+                    dest: '<%= config.dist %>'
+                }]
+            }
+        },
+
+        // By default, your `index.html`'s <!-- Usemin block --> will take care of
+        // minification. These next options are pre-configured if you do not wish
+        // to use the Usemin blocks.
+        // cssmin: {
+        //     dist: {
+        //         files: {
+        //             '<%= config.dist %>/styles/main.css': [
+        //                 '.tmp/styles/{,*/}*.css',
+        //                 '<%= config.app %>/styles/{,*/}*.css'
+        //             ]
+        //         }
+        //     }
+        // },
+        // uglify: {
+        //     dist: {
+        //         files: {
+        //             '<%= config.dist %>/scripts/scripts.js': [
+        //                 '<%= config.dist %>/scripts/scripts.js'
+        //             ]
+        //         }
+        //     }
+        // },
+        // concat: {
+        //     dist: {}
+        // },
+
+        // Copies remaining files to places other tasks can use
+        copy: {
+            dist: {
+                files: [{
+                    expand: true,
+                    dot: true,
+                    cwd: '<%= config.app %>',
+                    dest: '<%= config.dist %>',
+                    src: [
+                        '*.{ico,png,txt}',
+                        '.htaccess',
+                        'images/{,*/}*.webp',
+                        '{,*/}*.html',
+                        'styles/fonts/{,*/}*.*'
+                    ]
+                }, {
+                    expand: true,
+                    dot: true,
+                    cwd: 'bower_components/bootstrap/dist',
+                    src: ['fonts/*.*'],
+                    dest: '<%= config.dist %>'
+                }]
+            },
+            styles: {
+                expand: true,
+                dot: true,
+                cwd: '<%= config.app %>/styles',
+                dest: '.tmp/styles/',
+                src: '{,*/}*.css'
+            }
+        },
+
+        // Run some tasks in parallel to speed up build process
+        concurrent: {
+            server: [
+                'copy:styles'
+            ],
+            test: [
+                'copy:styles'
+            ],
+            dist: [
+                'copy:styles',
+                'imagemin',
+                'svgmin'
+            ]
+        }
+    });
+
+
+    grunt.registerTask('serve', function (target) {
+        if (target === 'dist') {
+            return grunt.task.run(['build', 'connect:dist:keepalive']);
+        }
+
+        grunt.task.run([
+            'clean:server',
+            'concurrent:server',
+            'autoprefixer',
+            'connect:livereload',
+            'watch'
+        ]);
+    });
+
+    grunt.registerTask('server', function (target) {
+        grunt.log.warn('The `server` task has been deprecated. Use `grunt serve` to start a server.');
+        grunt.task.run([target ? ('serve:' + target) : 'serve']);
+    });
+
+    grunt.registerTask('test', function (target) {
+        if (target !== 'watch') {
+            grunt.task.run([
+                'clean:server',
+                'concurrent:test',
+                'autoprefixer'
+            ]);
+        }
+
+        grunt.task.run([
+            'connect:test',
+            'mocha'
+        ]);
+    });
+
+    grunt.registerTask('build', [
+        'clean:dist',
+        'useminPrepare:html',
+        'concurrent:dist',
+        'autoprefixer',
+        'concat',
+        'cssmin',
+        'uglify',
+        'imagemin',
+        'copy:dist',
+        'rev',
+        'usemin',
+        'htmlmin'
+    ]);
+
+    grunt.registerTask('default', [
+        'newer:jshint',
+        //'test',
+        'build'
+    ]);
+};
diff --git a/dev/app/images/background/standards1.jpg b/dev/app/images/background/standards1.jpg
deleted file mode 100644
index 35c973a..0000000
--- a/dev/app/images/background/standards1.jpg
+++ /dev/null
Binary files differ
diff --git a/dev/app/images/tools.jpg b/dev/app/images/tools.jpg
index 0cf919a..cc18688 100644
--- a/dev/app/images/tools.jpg
+++ b/dev/app/images/tools.jpg
Binary files differ
diff --git a/dev/app/index.html b/dev/app/index.html
index e8204b1..28665d5 100644
--- a/dev/app/index.html
+++ b/dev/app/index.html
@@ -1,268 +1,263 @@
-<!doctype html>
-<html lang="en" class="no-js">
-    <head>
-        <meta charset="utf-8">
-        <title>Californium (Cf) CoAP framework</title>
-        <meta name="description" content="">
-        <meta name="viewport" content="width=device-width, initial-scale=1">
-        <link rel="shortcut icon" href="/favicon.ico">
-        <!-- Place favicon.ico and apple-touch-icon.png in the root directory -->
-        <!-- build:css(app) styles/vendor.css -->
-        <!-- bower:css -->
-        <link rel="stylesheet" href="../bower_components/bootstrap/dist/css/bootstrap.css" />
-        <!-- endbower -->
-        <!-- endbuild -->
-        <!-- build:css({app,.tmp}) styles/main.css -->
-        <link rel="stylesheet" href="styles/main.css">
-        <!-- endbuild -->
-    </head>
-    
-	<body>
-        <!--[if lt IE 10]>
-            <p class="browsehappy">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
-        <![endif]-->
-        
-        
-<!-- NAVBAR ================================================== -->
-        <div class="navbar navbar-inverse navbar-fixed-top" role="navigation">
-			<div class="container">
-				<div class="navbar-header">
-	              <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
-	                <span class="sr-only">Toggle navigation</span>
-	                <span class="icon-bar"></span>
-	                <span class="icon-bar"></span>
-	                <span class="icon-bar"></span>
-	              </button>
-	              <a class="navbar-brand" href="#">Californium (Cf)</a>
-	            </div>
-				<div class="navbar-collapse collapse">
-					<ul class="nav navbar-nav">
-						<li class="active"><a href="index.html">About</a></li>
-						<li><a href="#sources">Sources</a></li>
-						<li><a href="#start">Getting Started</a></li>
-						<li><a href="#tools">Tools</a></li>
-						<li><a href="https://projects.eclipse.org/projects/technology.californium">Project Site</a></li>
-					</ul>
-					<ul class="nav navbar-nav pull-right">
-						<li style="margin-top:16px;"><div class="g-plusone" data-href="http://www.eclipse.org/californium/"></div></li>
-						<li><a class="navbar-brand2" href="http://iot.eclipse.org/">iot.eclipse.org</a></li>
-					</ul>
-				</div>
-				<!--/.nav-collapse -->
-			</div>
-		</div>
-
-
-<!-- Carousel
-================================================== -->
-		<div id="cfCarousel" class="carousel slide" data-ride="carousel">
-			<!-- Indicators -->
-			<ol class="carousel-indicators">
-				<li data-target="#cfCarousel" data-slide-to="0" class="active"></li>
-				<li data-target="#cfCarousel" data-slide-to="1"></li>
-				<li data-target="#cfCarousel" data-slide-to="2"></li>
-			</ol>
-			<div class="carousel-inner">
-				<div class="item java active">
-					<div class="container">
-						<div class="carousel-caption">
-							<h1>CoAP in Java.</h1>
-							<p>Californium is a powerful CoAP framework targetting back-end services and stronger Internet of Things devices. It provides a convenient API for RESTful Web services that support all of CoAP's features.</p>
-						</div>
-					</div>
-				</div>
-				<div class="item cloud">
-					<div class="container">
-						<div class="carousel-caption">
-							<h1 style="text-align: left; color: orange;">Perfect for IoT cloud services.</h1>
-							<p>Californium has an extremely scalable architecture and outperforms high-performance HTTP servers. CoAP's low overhead allows to handle millions of IoT devices with a single service instance. The flexible concurrency model allows to implement whatever is best for your application.</p>
-						</div>
-					</div>
-				</div>
-				<div class="item ietf">
-					<div class="container">
-						<div class="carousel-caption">
-							<h1>Standards compliant.</h1>
-							<p>Californium has been running code for the IETF and is passing all ETSI Plugtest test specifications.</p>
-						</div>
-					</div>
-				</div>
-			</div>
-			<a class="left carousel-control" href="#cfCarousel" role="button" data-slide="prev"><span class="glyphicon glyphicon-chevron-left"></span></a>
-			<a class="right carousel-control" href="#cfCarousel" role="button" data-slide="next"><span class="glyphicon glyphicon-chevron-right"></span></a>
-		</div><!-- /.carousel -->
-		
-<!-- Marketing messaging ================================================== -->
-		<!-- Wrap the rest of the page in another container to center all the content. -->
-		<div class="container">
-			<a name="sources"></a>
-			<div class="container marketing">
-				<!-- Three columns of text below the carousel -->
-				<div class="row">
-					<div class="col-sm-12 col-lg-4">
-						<img src="images/boxes/Cf_box_256.png" alt="Californium sources" style="width: 256px; height: 256px;">
-						<h2>Californium (Cf) Core</h2>
-						<p>Californium is the umbrella project for CoAP at the Eclipse Foundation. It provides the core protocol implementation and basic examples. You can simply include Californium in your own projects through Maven. The sources are hosted on GitHub, so you can easily contribute through pull requests. The READMEs in the repositories provide more detailed information.</p>
-						<p><a class="btn btn-default" href="https://github.com/eclipse/californium" role="button">Repository &raquo;</a></p>
-					</div><!-- /.col-lg-4 -->
-					<div class="col-sm-6 col-lg-2">
-						<img src="images/boxes/Sc_box_128.png" alt="Scandium sources" style="width: 137px; height: 128px; margin-top: 96px;">
-						<h2>Scandium (Sc)</h2>
-						<p>The Scandium (Sc) sub-project provides security for Californium. It implements DTLS&nbsp;1.2 to secure your application through ECC with pre-shared keys, certificates, or raw public keys.</p>
-						<p><a class="btn btn-default" href="https://github.com/eclipse/californium.scandium" role="button">Repository &raquo;</a></p>
-					</div><!-- /.col-lg-2 -->
-					<div class="col-sm-6 col-lg-2">
-						<img src="images/boxes/Ac_box_128.png" alt="Actinium sources" style="width: 137px; height: 128px; margin-top: 96px;">
-						<h2>Actinium (Ac)</h2>
-						<p>Actinium (Ac) is the app-server for Californium to realize IoT mashups! Your JavaScript apps become available as RESTful resources and can directly talk to IoT devices using our CoapRequest object.</p>
-						<p><a class="btn btn-default" href="https://github.com/eclipse/californium.actinium" role="button">Repository &raquo;</a></p>
-					</div><!-- /.col-lg-2 -->
-					<div class="col-sm-6 col-lg-2">
-						<img src="images/tools.jpg" alt="Tools sources" style="width: 128px; height: 192px; margin-top: 32px;">
-						<h2>CoAP Tools</h2>
-						<p>This repository provides CoAP tools that also serve as examples. Use CoAPBench to benchmark your CoAP solutions or simply use our cf-client to interact with your devices from the command line.</p>
-						<p><a class="btn btn-default" href="https://github.com/eclipse/californium.tools" role="button">Repository &raquo;</a></p>
-					</div><!-- /.col-lg-2 -->
-					<div class="col-sm-6 col-lg-2">
-						<img src="images/connector.jpg" alt="Connector sources" style="width: 128px; height: 90px; margin-top: 134px;">
-						<h2>Element Connector</h2>
-						<p>The element-connector abstracts from the different transports. It provides the basic UDP connector and an interface to implement new ones like the Scandium DTLS connector.</p>
-						<p><a class="btn btn-default" href="https://github.com/eclipse/californium.element-connector" role="button">Repository &raquo;</a></p>
-					</div><!-- /.col-lg-2 -->
-				</div><!-- /.row -->
-			</div>
-
-<!-- Featurettes ================================================== -->
-			<a name="start"></a>
-			<hr class="featurette-divider">
-			
-			<div class="row featurette">
-				<div class="col-md-7">
-					<h2 class="featurette-heading">Getting started. <span class="text-muted">Take the tutorial.</span></h2>
-					<p class="lead">The Internet of Things if growing, but how can you build your own connected objects? Together with MQTT, CoAP is one of the popular IoT protocols. It provides answers to the typical IoT constraints: it is bandwidth efficient and fits in constrained embedded environment while providing friendly and discoverable RESTful API.</p>
-				</div>
-				<div class="col-md-5">
-					<a href="http://goo.gl/LLQ03w"><img class="featurette-image img-responsive" src="images/tutorial.jpg" alt="Tutorial slides"></a>
-				</div>
-			</div>
-			
-			<a name="tools"></a>
-			<hr class="featurette-divider">
-				
-			<div class="row featurette">
-				<div class="col-md-5">
-					<a href="https://addons.mozilla.org/en-US/firefox/addon/copper-270430/"><img class="featurette-image img-responsive" src="images/boxes/Cu_box_512.png" alt="More CoAP tools"></a>
-				</div>
-				<div class="col-md-7">
-					<h2 class="featurette-heading">More tools. <span class="text-muted">Get the full CoAP experience.</span></h2>
-					<p class="lead">The Copper (Cu) CoAP user-agent is an add-on for the Firefox Web browser. It allows browsing, bookmarking, and direct interaction with CoAP resources. Simply enter a CoAP URI into the address bar. To get started you can test the following CoAP sandboxes:</p>
-					<ul>
-					<li><a href="coap://iot.eclipse.org/">coap://iot.eclipse.org/</a></li>
-					<li><a href="coap://iot.eclipse.org/">coap://vs0.inf.ethz.ch/</a></li>
-					<li><a href="coap://iot.eclipse.org/">coap://coap.me/</a></li>
-					</ul>
-					<p class="lead">Check <a href="http://coap.technology">coap.technology</a> for more material.</p>
-				</div>
-			</div>
-			
-		</div>
-
-		<div class="footer">
-			<div class="container">
-					
-				<div class="row">
-					
-					<div class="col-sx-6 col-sm-6 col-md-3 col-lg-3 hidden-print">
-						<h2>Eclipse Foundation</h2>
-						<ul class="nav">
-							<li><a href="//www.eclipse.org/org/">About us</a></li>
-							<li><a href="//www.eclipse.org/org/foundation/contact.php">Contact Us</a></li>
-							<li><a href="//www.eclipse.org/donate">Donate</a></li>
-							<li><a href="//www.eclipse.org/org/documents/">Governance</a></li>
-							<li><a href="//www.eclipse.org/artwork/">Logo and Artwork</a></li>
-							<li><a href="//www.eclipse.org/org/foundation/directors.php">Board of Directors</a></li>
-						</ul>
-					</div>
-					
-					<div class="col-sx-6 col-sm-6 col-md-3 col-lg-3 hidden-print">
-						<h2>Legal</h2>
-						<ul class="nav">
-							<li><a href="//www.eclipse.org/legal/privacy.php">Privacy Policy</a></li>
-							<li><a href="//www.eclipse.org/legal/termsofuse.php">Terms of Use</a></li>
-							<li><a href="//www.eclipse.org/legal/copyright.php">Copyright Agent</a></li>
-							<li><a href="//www.eclipse.org/org/documents/epl-v10.php">Eclipse Public License </a></li>
-							<li><a href="//www.eclipse.org/legal/">Legal Resources </a></li>
-						</ul>
-					</div>
-					
-					<div class="col-sx-6 col-sm-6 col-md-3 col-lg-3 hidden-print">
-						<h2>Useful Links</h2>
-						<ul class="nav">
-							<li><a href="//bugs.eclipse.org/bugs/">Report a Bug</a></li>
-							<li><a href="//help.eclipse.org/">Documentation</a></li>
-							<li><a href="//www.eclipse.org/contribute/">How to Contribute</a></li>
-							<li><a href="//www.eclipse.org/mail/">Mailing Lists</a></li>
-							<li><a href="//www.eclipse.org/forums/">Forums</a></li>
-							<li><a href="//marketplace.eclipse.org">Marketplace</a></li>
-						</ul>
-					</div>
-					
-					<div class="col-sx-6 col-sm-6 col-md-3 col-lg-3 hidden-print">
-						<h2>Other</h2>
-						<ul class="nav">
-							<li><a href="//www.eclipse.org/ide/">IDE and Tools</a></li>
-							<li><a href="//www.eclipse.org/projects">Community of Projects</a></li>
-							<li><a href="//www.eclipse.org/org/workinggroups/">Working Groups</a></li>
-						</ul>
-						<ul class="list-inline social-media">
-							<li><a href="//twitter.com/EclipseFdn"><i class="fa fa-twitter-square"></i></a></li>
-							<li><a href="//plus.google.com/+Eclipse"><i class="fa fa-google-plus-square"></i></a></li>
-							<li><a href="//www.facebook.com/eclipse.org"><i class="fa fa-facebook-square"></i> </a></li>
-							<li><a href="//www.youtube.com/user/EclipseFdn"><i class="fa fa-youtube-square"></i></a></li>
-						</ul>
-					</div>
-					
-					<div id="copyright" class="col-sx-12 col-sm-12 col-md-12 col-lg-12 hidden-print">
-						<div>
-							<span class="hidden-print"><img src="http://projects.eclipse.org/sites/all/themes/solstice/public/images/logo/eclipse-logo-bw-800x188.png" alt="Eclipse.org black and white logo" width="166" height="39" class="logo-eclipse-white"/></span>
-							<p id="copyright-text">Copyright &copy; 2014 The Eclipse Foundation. All Rights Reserved.</p>
-						</div>
-					</div>
-					
-				</div>        
-			</div>
-		</div>
-		
-		<!-- Place this tag after the last +1 button tag. -->
-		<script type="text/javascript">
-			(function() {
-			var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
-			po.src = 'https://apis.google.com/js/plusone.js';
-			var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
-			})();
-		</script>
-		
-		<!-- Google Analytics: change UA-XXXXX-X to be your site's ID. -->
-		<script>
-			(function(b,o,i,l,e,r){b.GoogleAnalyticsObject=l;b[l]||(b[l]=
-			function(){(b[l].q=b[l].q||[]).push(arguments)});b[l].l=+new Date;
-			e=o.createElement(i);r=o.getElementsByTagName(i)[0];
-			e.src='//www.google-analytics.com/analytics.js';
-			r.parentNode.insertBefore(e,r)}(window,document,'script','ga'));
-			ga('create','UA-XXXXX-X');ga('send','pageview');
-		</script>
-		
-		<!-- build:js scripts/vendor.js -->
-		<!-- bower:js -->
-		<script src="../bower_components/jquery/dist/jquery.js"></script>
-		<script src="../bower_components/bootstrap/dist/js/bootstrap.js"></script>
-		<script src="../bower_components/scrollup/dist/jquery.scrollUp.min.js"></script>
-		<!-- endbower -->
-		<!-- endbuild -->
-		
-		<!-- build:js(app) scripts/main.js -->
-		<script src="scripts/main.js"></script>
-		<!-- endbuild -->
-	
-	</body>
-</html>
+<!doctype html>
+<html lang="en" class="no-js">
+    <head>
+        <meta charset="utf-8">
+        <title>Californium (Cf) CoAP framework</title>
+        <meta name="description" content="">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <link rel="shortcut icon" href="/favicon.ico">
+        <!-- Place favicon.ico and apple-touch-icon.png in the root directory -->
+        <!-- build:css(app) styles/vendor.css -->
+        <!-- bower:css -->
+        <link rel="stylesheet" href="../bower_components/bootstrap/dist/css/bootstrap.css" />
+        <!-- endbower -->
+        <!-- endbuild -->
+        <!-- build:css({app,.tmp}) styles/main.css -->
+        <link rel="stylesheet" href="styles/main.css">
+        <!-- endbuild -->
+    </head>
+    
+	<body>
+        <!--[if lt IE 10]>
+            <p class="browsehappy">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
+        <![endif]-->
+        
+        
+<!-- NAVBAR ================================================== -->
+        <div class="navbar navbar-inverse navbar-fixed-top" role="navigation">
+			<div class="container">
+				<div class="navbar-header">
+	              <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
+	                <span class="sr-only">Toggle navigation</span>
+	                <span class="icon-bar"></span>
+	                <span class="icon-bar"></span>
+	                <span class="icon-bar"></span>
+	              </button>
+	              <a class="navbar-brand" href="#">Californium (Cf)</a>
+	            </div>
+				<div class="navbar-collapse collapse">
+					<ul class="nav navbar-nav">
+						<li class="active"><a href="#top">About</a></li>
+						<li><a href="#sources">Sources</a></li>
+						<li><a href="#start">Getting Started</a></li>
+						<li><a href="#tools">Tools</a></li>
+						<li><a href="https://projects.eclipse.org/projects/technology.californium">Learn more</a></li>
+					</ul>
+					<ul class="nav navbar-nav pull-right">
+						<li style="margin-top:18px;"><div class="g-plusone" data-href="http://www.eclipse.org/californium/"></div></li>
+						<li><a class="navbar-brand2" href="http://iot.eclipse.org/">iot.eclipse.org</a></li>
+					</ul>
+				</div>
+				<!--/.nav-collapse -->
+			</div>
+		</div>
+
+
+<!-- Carousel
+================================================== -->
+		<div id="cfCarousel" class="carousel slide" data-ride="carousel">
+			<!-- Indicators -->
+			<ol class="carousel-indicators">
+				<li data-target="#cfCarousel" data-slide-to="0" class="active"></li>
+				<li data-target="#cfCarousel" data-slide-to="1"></li>
+				<li data-target="#cfCarousel" data-slide-to="2"></li>
+			</ol>
+			<div class="carousel-inner">
+				<div class="item java active">
+					<div class="container">
+						<div class="carousel-caption">
+							<h1>CoAP in Java.</h1>
+							<p>Californium is a powerful CoAP framework targetting back-end services and stronger Internet of Things devices. It provides a convenient API for RESTful Web services that support all of CoAP's features.</p>
+						</div>
+					</div>
+				</div>
+				<div class="item cloud">
+					<div class="container">
+						<div class="carousel-caption">
+							<h1 style="text-align: left; color: orange;">Perfect for IoT cloud services.</h1>
+							<p>Californium has an extremely scalable architecture and outperforms high-performance HTTP servers. CoAP's low overhead allows to handle millions of IoT devices with a single service instance. The flexible concurrency model allows to implement whatever is best for your application.</p>
+						</div>
+					</div>
+				</div>
+				<div class="item ietf">
+					<div class="container">
+						<div class="carousel-caption">
+							<h1>Standards compliant.</h1>
+							<p>Californium has been running code for the IETF and is passing all ETSI Plugtest test specifications.</p>
+						</div>
+					</div>
+				</div>
+			</div>
+			<a class="left carousel-control" href="#cfCarousel" role="button" data-slide="prev"><span class="glyphicon glyphicon-chevron-left"></span></a>
+			<a class="right carousel-control" href="#cfCarousel" role="button" data-slide="next"><span class="glyphicon glyphicon-chevron-right"></span></a>
+		</div><!-- /.carousel -->
+		
+<!-- Marketing messaging ================================================== -->
+		<!-- Wrap the rest of the page in another container to center all the content. -->
+		<div class="container">
+			<a name="sources"></a>
+			<div class="container marketing">
+				<!-- Three columns of text below the carousel -->
+				<div class="row">
+					<div class="col-sm-12 col-lg-6 item">
+						<img src="images/boxes/Cf_box_256.png" alt="Californium sources" style="width: 256px; height: 256px;">
+						<h2>Californium (Cf) core</h2>
+						<p>The project is divided into five sub-projects. The Californium (Cf) core provides the central framework with the protocol implementation to build your Internet of Things applications. This repository also includes example projects to get you started. All Californium sources are hosted on GitHub, so you can easily contribute through pull requests.</p>
+						<p>Californium (Cf) is dual-licensed under EPL and EDL. The latter is a BSD-like license, which means the Cf CoAP framework can be used together with proprietary code to implement your IoT product!</p> 
+						<p>Cf is available in Maven Central and very easy to consume in your Java project. We have got your back covered from OSGi wrapper to HTTP-CoAP cross-proxy to advanced test suites that have been used at the ETSI Plugtests.</p>  
+						<a class="btn btn-default" href="https://github.com/eclipse/californium" role="button">Repository &raquo;</a>
+					</div><!-- /.col-lg-4 -->
+					<div class="col-sm-6 col-lg-3 item">
+						<img src="images/boxes/Sc_box_128.png" alt="Scandium sources" style="width: 137px; height: 128px;">
+						<h2>Scandium (Sc)</h2>
+						<p>The Scandium (Sc) sub-project provides security for Californium. It implements DTLS&nbsp;1.2 to secure your application through ECC with pre-shared keys, certificates, or raw public keys.</p>
+						<a class="btn btn-default" href="https://github.com/eclipse/californium.scandium" role="button">Repository &raquo;</a>
+					</div><!-- /.col-lg-2 -->
+					<div class="col-sm-6 col-lg-3 item">
+						<img src="images/boxes/Ac_box_128.png" alt="Actinium sources" style="width: 137px; height: 128px;">
+						<h2>Actinium (Ac)</h2>
+						<p>Actinium (Ac) is the app-server for Californium to realize IoT mashups! Your JavaScript apps become available as RESTful resources and can directly talk to IoT devices using our CoapRequest object API.</p>
+						<a class="btn btn-default" href="https://github.com/eclipse/californium.actinium" role="button">Repository &raquo;</a>
+					</div><!-- /.col-lg-2 -->
+					<div class="col-sm-6 col-lg-3 item">
+						<img src="images/tools.jpg" alt="Tools sources" style="width: 128px; height: 81px; margin-top: 47px;">
+						<h2>CoAP tools</h2>
+						<p>This repository provides CoAP tools that also serve as examples. Use CoAPBench to benchmark your CoAP solutions or simply use our cf-client to interact with your devices from the command line.</p>
+						<a class="btn btn-default" href="https://github.com/eclipse/californium.tools" role="button">Repository &raquo;</a>
+					</div><!-- /.col-lg-2 -->
+					<div class="col-sm-6 col-lg-3 item">
+						<img src="images/connector.jpg" alt="Connector sources" style="width: 128px; height: 90px; margin-top: 38px;">
+						<h2>Connector</h2>
+						<p>The element-connector abstracts from the different transports CoAP can use. It provides the basic UDPConnector as well as the interface to implement new connectors like the DtlsConnector of Scandium.</p>
+						<a class="btn btn-default" href="https://github.com/eclipse/californium.element-connector" role="button">Repository &raquo;</a>
+					</div><!-- /.col-lg-2 -->
+				</div><!-- /.row -->
+			</div>
+
+<!-- Featurettes ================================================== -->
+			<a name="start"></a>
+			<hr class="featurette-divider">
+			
+			<div class="row featurette">
+				<div class="col-md-7">
+					<h2 class="featurette-heading">Getting started. <span class="text-muted">Take the tutorial.</span></h2>
+					<p class="lead">The Internet of Things if growing, but how can you build your own connected objects? Together with MQTT, CoAP is one of the popular IoT protocols. It provides answers to the typical IoT constraints: it is bandwidth efficient and fits in constrained embedded environment while providing friendly and discoverable RESTful API.</p>
+				</div>
+				<div class="col-md-5">
+					<a href="http://goo.gl/LLQ03w"><img class="featurette-image img-responsive" src="images/tutorial.jpg" alt="Tutorial slides"></a>
+				</div>
+			</div>
+			
+			<a name="tools"></a>
+			<hr class="featurette-divider">
+				
+			<div class="row featurette">
+				<div class="col-md-5">
+					<a href="https://addons.mozilla.org/en-US/firefox/addon/copper-270430/"><img class="featurette-image img-responsive" src="images/boxes/Cu_box_512.png" alt="More CoAP tools"></a>
+				</div>
+				<div class="col-md-7">
+					<h2 class="featurette-heading">More tools. <span class="text-muted">Get the full CoAP experience.</span></h2>
+					<p class="lead">The Copper (Cu) CoAP user-agent is an add-on for the Firefox Web browser. It allows browsing, bookmarking, and direct interaction with CoAP resources. Simply enter a CoAP URI into the address bar. To get started you can test the following CoAP sandboxes:</p>
+					<ul>
+					<li><a href="coap://iot.eclipse.org/">coap://iot.eclipse.org/</a></li>
+					<li><a href="coap://iot.eclipse.org/">coap://vs0.inf.ethz.ch/</a></li>
+					<li><a href="coap://iot.eclipse.org/">coap://coap.me/</a></li>
+					</ul>
+					<p class="lead">Check <a href="http://coap.technology">coap.technology</a> for more material.</p>
+				</div>
+			</div>
+			
+		</div>
+
+		<div class="footer">
+			<div class="container">
+					
+				<div class="row">
+					
+					<div class="col-xs-12 col-sm-6 col-md-3 col-lg-3 hidden-print">
+						<h2>Eclipse Foundation</h2>
+						<ul class="nav">
+							<li><a href="//www.eclipse.org/org/">About us</a></li>
+							<li><a href="//www.eclipse.org/org/foundation/contact.php">Contact Us</a></li>
+							<li><a href="//www.eclipse.org/donate">Donate</a></li>
+							<li><a href="//www.eclipse.org/org/documents/">Governance</a></li>
+							<li><a href="//www.eclipse.org/artwork/">Logo and Artwork</a></li>
+							<li><a href="//www.eclipse.org/org/foundation/directors.php">Board of Directors</a></li>
+						</ul>
+					</div>
+					
+					<div class="col-xs-12 col-sm-6 col-md-3 col-lg-3 hidden-print">
+						<h2>Legal</h2>
+						<ul class="nav">
+							<li><a href="//www.eclipse.org/legal/privacy.php">Privacy Policy</a></li>
+							<li><a href="//www.eclipse.org/legal/termsofuse.php">Terms of Use</a></li>
+							<li><a href="//www.eclipse.org/legal/copyright.php">Copyright Agent</a></li>
+							<li><a href="//www.eclipse.org/org/documents/epl-v10.php">Eclipse Public License </a></li>
+							<li><a href="//www.eclipse.org/legal/">Legal Resources </a></li>
+						</ul>
+					</div>
+					
+					<div class="col-xs-12 col-sm-6 col-md-3 col-lg-3 hidden-print">
+						<h2>Useful Links</h2>
+						<ul class="nav">
+							<li><a href="//bugs.eclipse.org/bugs/">Report a Bug</a></li>
+							<li><a href="//help.eclipse.org/">Documentation</a></li>
+							<li><a href="//www.eclipse.org/contribute/">How to Contribute</a></li>
+							<li><a href="//www.eclipse.org/mail/">Mailing Lists</a></li>
+							<li><a href="//www.eclipse.org/forums/">Forums</a></li>
+							<li><a href="//marketplace.eclipse.org">Marketplace</a></li>
+						</ul>
+					</div>
+					<div class="col-xs-12 col-sm-6 col-md-3 col-lg-3 hidden-print">
+						<h2>Other</h2>
+						<ul class="nav">
+							<li><a href="//www.eclipse.org/ide/">IDE and Tools</a></li>
+							<li><a href="//www.eclipse.org/projects">Community of Projects</a></li>
+							<li><a href="//www.eclipse.org/org/workinggroups/">Working Groups</a></li>
+						</ul>
+					</div>
+					
+					<div id="copyright" class="col-xs-12 col-sm-12 col-md-12 col-lg-12 hidden-print">
+						<div>
+							<span class="hidden-print"><img src="http://projects.eclipse.org/sites/all/themes/solstice/public/images/logo/eclipse-logo-bw-800x188.png" alt="Eclipse.org black and white logo" width="166" height="39" class="logo-eclipse-white"/></span>
+							<p id="copyright-text">Copyright &copy; 2014 The Eclipse Foundation. All Rights Reserved.</p>
+						</div>
+					</div>
+					
+				</div>        
+			</div>
+		</div>
+		
+		<!-- Place this tag after the last +1 button tag. -->
+		<script type="text/javascript">
+			(function() {
+			var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
+			po.src = 'https://apis.google.com/js/plusone.js';
+			var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
+			})();
+		</script>
+		
+		<!-- Google Analytics: change UA-XXXXX-X to be your site's ID. -->
+		<script>
+			(function(b,o,i,l,e,r){b.GoogleAnalyticsObject=l;b[l]||(b[l]=
+			function(){(b[l].q=b[l].q||[]).push(arguments)});b[l].l=+new Date;
+			e=o.createElement(i);r=o.getElementsByTagName(i)[0];
+			e.src='//www.google-analytics.com/analytics.js';
+			r.parentNode.insertBefore(e,r)}(window,document,'script','ga'));
+			ga('create','UA-XXXXX-X');ga('send','pageview');
+		</script>
+		
+		<!-- build:js scripts/vendor.js -->
+		<!-- bower:js -->
+		<script src="../bower_components/jquery/dist/jquery.js"></script>
+		<script src="../bower_components/bootstrap/dist/js/bootstrap.js"></script>
+		<script src="../bower_components/scrollup/dist/jquery.scrollUp.min.js"></script>
+		<!-- endbower -->
+		<!-- endbuild -->
+		
+		<!-- build:js(app) scripts/main.js -->
+		<script src="scripts/main.js"></script>
+		<!-- endbuild -->
+	
+	</body>
+</html>
diff --git a/dev/app/scripts/main.js b/dev/app/scripts/main.js
index 55881f4..9d47804 100644
--- a/dev/app/scripts/main.js
+++ b/dev/app/scripts/main.js
@@ -1,19 +1,23 @@
-$(function () {
-	/*jshint strict: true */
-    $.scrollUp({
-        scrollName: 'scrollUp',      // Element ID
-        scrollDistance: 450,         // Distance from top/bottom before showing element (px)
-        scrollFrom: 'top',           // 'top' or 'bottom'
-        scrollSpeed: 300,            // Speed back to top (ms)
-        easingType: 'linear',        // Scroll to top easing (see http://easings.net/)
-        animation: 'fade',           // Fade, slide, none
-        animationSpeed: 200,         // Animation speed (ms)
-        scrollTrigger: false,        // Set a custom triggering element. Can be an HTML string or jQuery object
-        scrollTarget: false,         // Set a custom target element for scrolling to. Can be element or number
-        scrollText: 'Scroll to top', // Text for element, can contain HTML
-        scrollTitle: false,          // Set a custom <a> title if required.
-        scrollImg: true,            // Set true to use image
-        activeOverlay: false,        // Set CSS color to display scrollUp active point, e.g '#00FFFF'
-        zIndex: 2147483647           // Z-Index for the overlay
-    });
-});
+$('.carousel').carousel({
+   interval: 8000
+});
+
+$(function () {
+	/*jshint strict: true */
+    $.scrollUp({
+        scrollName: 'scrollUp',      // Element ID
+        scrollDistance: 450,         // Distance from top/bottom before showing element (px)
+        scrollFrom: 'top',           // 'top' or 'bottom'
+        scrollSpeed: 300,            // Speed back to top (ms)
+        easingType: 'linear',        // Scroll to top easing (see http://easings.net/)
+        animation: 'fade',           // Fade, slide, none
+        animationSpeed: 200,         // Animation speed (ms)
+        scrollTrigger: false,        // Set a custom triggering element. Can be an HTML string or jQuery object
+        scrollTarget: false,         // Set a custom target element for scrolling to. Can be element or number
+        scrollText: 'Scroll to top', // Text for element, can contain HTML
+        scrollTitle: false,          // Set a custom <a> title if required.
+        scrollImg: true,            // Set true to use image
+        activeOverlay: false,        // Set CSS color to display scrollUp active point, e.g '#00FFFF'
+        zIndex: 2147483647           // Z-Index for the overlay
+    });
+});
diff --git a/dev/app/styles/main.css b/dev/app/styles/main.css
index 4a8c5d8..d9c246b 100644
--- a/dev/app/styles/main.css
+++ b/dev/app/styles/main.css
@@ -25,25 +25,99 @@
     border-bottom: 1px solid #e5e5e5;
 }
 
+.navbar {
+	min-height: 60px;
+	background-color: #121320;
+	border: none;
+	padding: 0px 0px 0px 40px;
+}
+
 .navbar-brand {
-	width:50px;
+	width:60px;
+	height: 60px;
 	font-size: 0;
-	background:url('../images/logos/Cf_32.png') 9px 9px no-repeat;
+	background:url('../images/logos/Cf_48.png') 0px 6px no-repeat;
 }
 .navbar-brand2 {
 	width: 54px;
 	font-size: 0;
-    border-top: 2px solid transparent;
-	margin-bottom: -2px;
-	background:url('http://iot.eclipse.org/css/img/m2m_eclipse_logo.png') -36px 0 no-repeat;
+	background:url('http://iot.eclipse.org/css/img/m2m_eclipse_logo.png') -36px 5px no-repeat;
 }
 
-.navbar-nav > li > a:hover,
-.navbar-nav > li > a:focus {
-  border-top: 2px solid #eee;
-    padding-top: 13px;
+
+a
+{
+  color: #4b7d38;
 }
 
+/* Line 9 */
+a:focus
+{
+  outline-width: thin;
+  outline-style: dotted;
+  outline-color: #333333;
+  outline-offset: -2px;
+}
+
+/* Line 9 */
+a:hover, a:active
+{
+  outline-width: 0px;
+  outline-style: none;
+}
+
+/* Line 9 */
+a:hover
+{
+  color: #6bb151;
+}
+
+/* Line 9 */
+.nav > li > a
+{
+  display: block;
+}
+
+/* Line 9 */
+.nav > li > a:hover
+{
+  background-color: #eeeeee;
+}
+
+/* Line 9 */
+.navbar .nav > li > a
+{
+  float: none;
+  padding-top: 20px;
+  padding-right: 15px;
+  padding-bottom: 20px;
+  padding-left: 15px;
+  color: #c4c6dd;
+  text-shadow: #161726;
+  border-top-width: 2px;
+  border-top-style: solid;
+  border-top-color: #161726;
+}
+
+/* Line 9 */
+.navbar .nav > li > a:focus, .navbar .nav > li > a:hover
+{
+  color: #eff4f7;
+  background-color: transparent;
+  border-top-color: #eff4f7;
+}
+
+/* Line 9 */
+.navbar .nav > li > a:focus, .navbar .nav > li > a:hover
+{
+  color: #eff4f7;
+  background-color: transparent;
+  border-top-color: #eff4f7;
+}
+
+
+
+
 
 /* Make the masthead heading the same height as the navigation */
 .header h3 {
@@ -173,15 +247,15 @@
 -------------------------------------------------- */
 
 /* Center align the text within the three columns below the carousel */
-.marketing .col-lg-4 {
-  margin-bottom: 20px;
-  text-align: center;
-}
-.marketing .col-lg-2 {
-  margin-bottom: 20px;
+.marketing .item {
+  margin-bottom: 40px;
   text-align: center;
 }
 
+.marketing .item p {
+	text-align: justify;
+	margin: 10px 10px;
+}
 
 /* Featurettes
 ------------------------- */
@@ -200,7 +274,7 @@
 /* Responsive: Portrait tablets and up */
 @media screen and (min-width: 768px) {
     .container {
-        max-width: 1024px;
+        max-width: 1280px;
     }
 
     /* Remove the padding we set earlier */
diff --git a/images/20fd1ff1.tools.jpg b/images/20fd1ff1.tools.jpg
deleted file mode 100644
index 4a9684d..0000000
--- a/images/20fd1ff1.tools.jpg
+++ /dev/null
Binary files differ
diff --git a/images/973fb5ba.tools.jpg b/images/973fb5ba.tools.jpg
new file mode 100644
index 0000000..6cc6cbd
--- /dev/null
+++ b/images/973fb5ba.tools.jpg
Binary files differ
diff --git a/images/background/f34a6e2f.standards1.jpg b/images/background/f34a6e2f.standards1.jpg
deleted file mode 100644
index 3783f73..0000000
--- a/images/background/f34a6e2f.standards1.jpg
+++ /dev/null
Binary files differ
diff --git a/index.html b/index.html
index ef2677c..5dc5612 100644
--- a/index.html
+++ b/index.html
@@ -1,13 +1,13 @@
-<!DOCTYPE html><html lang=en class=no-js><head><meta charset=utf-8><title>Californium (Cf) CoAP framework</title><meta name=description content=""><meta name=viewport content="width=device-width, initial-scale=1"><link rel="shortcut icon" href=/595657ef.favicon.ico><!-- Place favicon.ico and apple-touch-icon.png in the root directory --><link rel=stylesheet href=styles/dfc57042.vendor.css><link rel=stylesheet href=styles/81ae7ec5.main.css><body><!--[if lt IE 10]>
-            <p class="browsehappy">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
-        <![endif]--><!-- NAVBAR ================================================== --><div class="navbar navbar-inverse navbar-fixed-top" role=navigation><div class=container><div class=navbar-header><button type=button class=navbar-toggle data-toggle=collapse data-target=.navbar-collapse><span class=sr-only>Toggle navigation</span> <span class=icon-bar></span> <span class=icon-bar></span> <span class=icon-bar></span></button> <a class=navbar-brand href=#>Californium (Cf)</a></div><div class="navbar-collapse collapse"><ul class="nav navbar-nav"><li class=active><a href=index.html>About</a></li><li><a href=#sources>Sources</a></li><li><a href=#start>Getting Started</a></li><li><a href=#tools>Tools</a></li><li><a href=https://projects.eclipse.org/projects/technology.californium>Project Site</a></li></ul><ul class="nav navbar-nav pull-right"><li style=margin-top:16px><div class=g-plusone data-href="http://www.eclipse.org/californium/"></div></li><li><a class=navbar-brand2 href="http://iot.eclipse.org/">iot.eclipse.org</a></li></ul></div><!--/.nav-collapse --></div></div><!-- Carousel
-================================================== --><div id=cfCarousel class="carousel slide" data-ride=carousel><!-- Indicators --><ol class=carousel-indicators><li data-target=#cfCarousel data-slide-to=0 class=active></li><li data-target=#cfCarousel data-slide-to=1></li><li data-target=#cfCarousel data-slide-to=2></li></ol><div class=carousel-inner><div class="item java active"><div class=container><div class=carousel-caption><h1>CoAP in Java.</h1><p>Californium is a powerful CoAP framework targetting back-end services and stronger Internet of Things devices. It provides a convenient API for RESTful Web services that support all of CoAP's features.</p></div></div></div><div class="item cloud"><div class=container><div class=carousel-caption><h1 style="text-align: left; color: orange">Perfect for IoT cloud services.</h1><p>Californium has an extremely scalable architecture and outperforms high-performance HTTP servers. CoAP's low overhead allows to handle millions of IoT devices with a single service instance. The flexible concurrency model allows to implement whatever is best for your application.</p></div></div></div><div class="item ietf"><div class=container><div class=carousel-caption><h1>Standards compliant.</h1><p>Californium has been running code for the IETF and is passing all ETSI Plugtest test specifications.</p></div></div></div></div><a class="left carousel-control" href=#cfCarousel role=button data-slide=prev><span class="glyphicon glyphicon-chevron-left"></span></a> <a class="right carousel-control" href=#cfCarousel role=button data-slide=next><span class="glyphicon glyphicon-chevron-right"></span></a></div><!-- /.carousel --><!-- Marketing messaging ================================================== --><!-- Wrap the rest of the page in another container to center all the content. --><div class=container><a name=sources></a><div class="container marketing"><!-- Three columns of text below the carousel --><div class=row><div class="col-sm-12 col-lg-4"><img src=images/boxes/35801f23.Cf_box_256.png alt="Californium sources" style="width: 256px; height: 256px"><h2>Californium (Cf) Core</h2><p>Californium is the umbrella project for CoAP at the Eclipse Foundation. It provides the core protocol implementation and basic examples. You can simply include Californium in your own projects through Maven. The sources are hosted on GitHub, so you can easily contribute through pull requests. The READMEs in the repositories provide more detailed information.</p><p><a class="btn btn-default" href=https://github.com/eclipse/californium role=button>Repository &raquo;</a></p></div><!-- /.col-lg-4 --><div class="col-sm-6 col-lg-2"><img src=images/boxes/37e4f308.Sc_box_128.png alt="Scandium sources" style="width: 137px; height: 128px; margin-top: 96px"><h2>Scandium (Sc)</h2><p>The Scandium (Sc) sub-project provides security for Californium. It implements DTLS&nbsp;1.2 to secure your application through ECC with pre-shared keys, certificates, or raw public keys.</p><p><a class="btn btn-default" href=https://github.com/eclipse/californium.scandium role=button>Repository &raquo;</a></p></div><!-- /.col-lg-2 --><div class="col-sm-6 col-lg-2"><img src=images/boxes/8588751b.Ac_box_128.png alt="Actinium sources" style="width: 137px; height: 128px; margin-top: 96px"><h2>Actinium (Ac)</h2><p>Actinium (Ac) is the app-server for Californium to realize IoT mashups! Your JavaScript apps become available as RESTful resources and can directly talk to IoT devices using our CoapRequest object.</p><p><a class="btn btn-default" href=https://github.com/eclipse/californium.actinium role=button>Repository &raquo;</a></p></div><!-- /.col-lg-2 --><div class="col-sm-6 col-lg-2"><img src=images/20fd1ff1.tools.jpg alt="Tools sources" style="width: 128px; height: 192px; margin-top: 32px"><h2>CoAP Tools</h2><p>This repository provides CoAP tools that also serve as examples. Use CoAPBench to benchmark your CoAP solutions or simply use our cf-client to interact with your devices from the command line.</p><p><a class="btn btn-default" href=https://github.com/eclipse/californium.tools role=button>Repository &raquo;</a></p></div><!-- /.col-lg-2 --><div class="col-sm-6 col-lg-2"><img src=images/e1bfbf57.connector.jpg alt="Connector sources" style="width: 128px; height: 90px; margin-top: 134px"><h2>Element Connector</h2><p>The element-connector abstracts from the different transports. It provides the basic UDP connector and an interface to implement new ones like the Scandium DTLS connector.</p><p><a class="btn btn-default" href=https://github.com/eclipse/californium.element-connector role=button>Repository &raquo;</a></p></div><!-- /.col-lg-2 --></div><!-- /.row --></div><!-- Featurettes ================================================== --><a name=start></a><hr class=featurette-divider><div class="row featurette"><div class=col-md-7><h2 class=featurette-heading>Getting started. <span class=text-muted>Take the tutorial.</span></h2><p class=lead>The Internet of Things if growing, but how can you build your own connected objects? Together with MQTT, CoAP is one of the popular IoT protocols. It provides answers to the typical IoT constraints: it is bandwidth efficient and fits in constrained embedded environment while providing friendly and discoverable RESTful API.</p></div><div class=col-md-5><a href=http://goo.gl/LLQ03w><img class="featurette-image img-responsive" src=images/d46a1065.tutorial.jpg alt="Tutorial slides"></a></div></div><a name=tools></a><hr class=featurette-divider><div class="row featurette"><div class=col-md-5><a href="https://addons.mozilla.org/en-US/firefox/addon/copper-270430/"><img class="featurette-image img-responsive" src=images/boxes/da6cde86.Cu_box_512.png alt="More CoAP tools"></a></div><div class=col-md-7><h2 class=featurette-heading>More tools. <span class=text-muted>Get the full CoAP experience.</span></h2><p class=lead>The Copper (Cu) CoAP user-agent is an add-on for the Firefox Web browser. It allows browsing, bookmarking, and direct interaction with CoAP resources. Simply enter a CoAP URI into the address bar. To get started you can test the following CoAP sandboxes:</p><ul><li><a href="coap://iot.eclipse.org/">coap://iot.eclipse.org/</a></li><li><a href="coap://iot.eclipse.org/">coap://vs0.inf.ethz.ch/</a></li><li><a href="coap://iot.eclipse.org/">coap://coap.me/</a></li></ul><p class=lead>Check <a href=http://coap.technology>coap.technology</a> for more material.</p></div></div></div><div class=footer><div class=container><div class=row><div class="col-sx-6 col-sm-6 col-md-3 col-lg-3 hidden-print"><h2>Eclipse Foundation</h2><ul class=nav><li><a href="//www.eclipse.org/org/">About us</a></li><li><a href=//www.eclipse.org/org/foundation/contact.php>Contact Us</a></li><li><a href=//www.eclipse.org/donate>Donate</a></li><li><a href="//www.eclipse.org/org/documents/">Governance</a></li><li><a href="//www.eclipse.org/artwork/">Logo and Artwork</a></li><li><a href=//www.eclipse.org/org/foundation/directors.php>Board of Directors</a></li></ul></div><div class="col-sx-6 col-sm-6 col-md-3 col-lg-3 hidden-print"><h2>Legal</h2><ul class=nav><li><a href=//www.eclipse.org/legal/privacy.php>Privacy Policy</a></li><li><a href=//www.eclipse.org/legal/termsofuse.php>Terms of Use</a></li><li><a href=//www.eclipse.org/legal/copyright.php>Copyright Agent</a></li><li><a href=//www.eclipse.org/org/documents/epl-v10.php>Eclipse Public License</a></li><li><a href="//www.eclipse.org/legal/">Legal Resources</a></li></ul></div><div class="col-sx-6 col-sm-6 col-md-3 col-lg-3 hidden-print"><h2>Useful Links</h2><ul class=nav><li><a href="//bugs.eclipse.org/bugs/">Report a Bug</a></li><li><a href="//help.eclipse.org/">Documentation</a></li><li><a href="//www.eclipse.org/contribute/">How to Contribute</a></li><li><a href="//www.eclipse.org/mail/">Mailing Lists</a></li><li><a href="//www.eclipse.org/forums/">Forums</a></li><li><a href=//marketplace.eclipse.org>Marketplace</a></li></ul></div><div class="col-sx-6 col-sm-6 col-md-3 col-lg-3 hidden-print"><h2>Other</h2><ul class=nav><li><a href="//www.eclipse.org/ide/">IDE and Tools</a></li><li><a href=//www.eclipse.org/projects>Community of Projects</a></li><li><a href="//www.eclipse.org/org/workinggroups/">Working Groups</a></li></ul><ul class="list-inline social-media"><li><a href=//twitter.com/EclipseFdn><i class="fa fa-twitter-square"></i></a></li><li><a href=//plus.google.com/+Eclipse><i class="fa fa-google-plus-square"></i></a></li><li><a href=//www.facebook.com/eclipse.org><i class="fa fa-facebook-square"></i></a></li><li><a href=//www.youtube.com/user/EclipseFdn><i class="fa fa-youtube-square"></i></a></li></ul></div><div id=copyright class="col-sx-12 col-sm-12 col-md-12 col-lg-12 hidden-print"><div><span class=hidden-print><img src=http://projects.eclipse.org/sites/all/themes/solstice/public/images/logo/eclipse-logo-bw-800x188.png alt="Eclipse.org black and white logo" width=166 height=39 class=logo-eclipse-white></span><p id=copyright-text>Copyright &copy; 2014 The Eclipse Foundation. All Rights Reserved.</p></div></div></div></div></div><!-- Place this tag after the last +1 button tag. --><script type=text/javascript>(function() {
-			var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
-			po.src = 'https://apis.google.com/js/plusone.js';
-			var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
-			})();</script><!-- Google Analytics: change UA-XXXXX-X to be your site's ID. --><script>(function(b,o,i,l,e,r){b.GoogleAnalyticsObject=l;b[l]||(b[l]=
-			function(){(b[l].q=b[l].q||[]).push(arguments)});b[l].l=+new Date;
-			e=o.createElement(i);r=o.getElementsByTagName(i)[0];
-			e.src='//www.google-analytics.com/analytics.js';
-			r.parentNode.insertBefore(e,r)}(window,document,'script','ga'));
-			ga('create','UA-XXXXX-X');ga('send','pageview');</script><script src=scripts/3ef39fab.vendor.js></script><script src=scripts/73b35626.main.js></script>
\ No newline at end of file
+<!DOCTYPE html><html lang=en class=no-js><head><meta charset=utf-8><title>Californium (Cf) CoAP framework</title><meta name=description content=""><meta name=viewport content="width=device-width, initial-scale=1"><link rel="shortcut icon" href=/595657ef.favicon.ico><!-- Place favicon.ico and apple-touch-icon.png in the root directory --><link rel=stylesheet href=styles/dfc57042.vendor.css><link rel=stylesheet href=styles/f5629f8c.main.css><body><!--[if lt IE 10]>
+            <p class="browsehappy">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
+        <![endif]--><!-- NAVBAR ================================================== --><div class="navbar navbar-inverse navbar-fixed-top" role=navigation><div class=container><div class=navbar-header><button type=button class=navbar-toggle data-toggle=collapse data-target=.navbar-collapse><span class=sr-only>Toggle navigation</span> <span class=icon-bar></span> <span class=icon-bar></span> <span class=icon-bar></span></button> <a class=navbar-brand href=#>Californium (Cf)</a></div><div class="navbar-collapse collapse"><ul class="nav navbar-nav"><li class=active><a href=#top>About</a></li><li><a href=#sources>Sources</a></li><li><a href=#start>Getting Started</a></li><li><a href=#tools>Tools</a></li><li><a href=https://projects.eclipse.org/projects/technology.californium>Learn more</a></li></ul><ul class="nav navbar-nav pull-right"><li style=margin-top:18px><div class=g-plusone data-href="http://www.eclipse.org/californium/"></div></li><li><a class=navbar-brand2 href="http://iot.eclipse.org/">iot.eclipse.org</a></li></ul></div><!--/.nav-collapse --></div></div><!-- Carousel
+================================================== --><div id=cfCarousel class="carousel slide" data-ride=carousel><!-- Indicators --><ol class=carousel-indicators><li data-target=#cfCarousel data-slide-to=0 class=active></li><li data-target=#cfCarousel data-slide-to=1></li><li data-target=#cfCarousel data-slide-to=2></li></ol><div class=carousel-inner><div class="item java active"><div class=container><div class=carousel-caption><h1>CoAP in Java.</h1><p>Californium is a powerful CoAP framework targetting back-end services and stronger Internet of Things devices. It provides a convenient API for RESTful Web services that support all of CoAP's features.</p></div></div></div><div class="item cloud"><div class=container><div class=carousel-caption><h1 style="text-align: left; color: orange">Perfect for IoT cloud services.</h1><p>Californium has an extremely scalable architecture and outperforms high-performance HTTP servers. CoAP's low overhead allows to handle millions of IoT devices with a single service instance. The flexible concurrency model allows to implement whatever is best for your application.</p></div></div></div><div class="item ietf"><div class=container><div class=carousel-caption><h1>Standards compliant.</h1><p>Californium has been running code for the IETF and is passing all ETSI Plugtest test specifications.</p></div></div></div></div><a class="left carousel-control" href=#cfCarousel role=button data-slide=prev><span class="glyphicon glyphicon-chevron-left"></span></a> <a class="right carousel-control" href=#cfCarousel role=button data-slide=next><span class="glyphicon glyphicon-chevron-right"></span></a></div><!-- /.carousel --><!-- Marketing messaging ================================================== --><!-- Wrap the rest of the page in another container to center all the content. --><div class=container><a name=sources></a><div class="container marketing"><!-- Three columns of text below the carousel --><div class=row><div class="col-sm-12 col-lg-6 item"><img src=images/boxes/35801f23.Cf_box_256.png alt="Californium sources" style="width: 256px; height: 256px"><h2>Californium (Cf) core</h2><p>The project is divided into five sub-projects. The Californium (Cf) core provides the central framework with the protocol implementation to build your Internet of Things applications. This repository also includes example projects to get you started. All Californium sources are hosted on GitHub, so you can easily contribute through pull requests.</p><p>Californium (Cf) is dual-licensed under EPL and EDL. The latter is a BSD-like license, which means the Cf CoAP framework can be used together with proprietary code to implement your IoT product!</p><p>Cf is available in Maven Central and very easy to consume in your Java project. We have got your back covered from OSGi wrapper to HTTP-CoAP cross-proxy to advanced test suites that have been used at the ETSI Plugtests.</p><a class="btn btn-default" href=https://github.com/eclipse/californium role=button>Repository &raquo;</a></div><!-- /.col-lg-4 --><div class="col-sm-6 col-lg-3 item"><img src=images/boxes/37e4f308.Sc_box_128.png alt="Scandium sources" style="width: 137px; height: 128px"><h2>Scandium (Sc)</h2><p>The Scandium (Sc) sub-project provides security for Californium. It implements DTLS&nbsp;1.2 to secure your application through ECC with pre-shared keys, certificates, or raw public keys.</p><a class="btn btn-default" href=https://github.com/eclipse/californium.scandium role=button>Repository &raquo;</a></div><!-- /.col-lg-2 --><div class="col-sm-6 col-lg-3 item"><img src=images/boxes/8588751b.Ac_box_128.png alt="Actinium sources" style="width: 137px; height: 128px"><h2>Actinium (Ac)</h2><p>Actinium (Ac) is the app-server for Californium to realize IoT mashups! Your JavaScript apps become available as RESTful resources and can directly talk to IoT devices using our CoapRequest object API.</p><a class="btn btn-default" href=https://github.com/eclipse/californium.actinium role=button>Repository &raquo;</a></div><!-- /.col-lg-2 --><div class="col-sm-6 col-lg-3 item"><img src=images/973fb5ba.tools.jpg alt="Tools sources" style="width: 128px; height: 81px; margin-top: 47px"><h2>CoAP tools</h2><p>This repository provides CoAP tools that also serve as examples. Use CoAPBench to benchmark your CoAP solutions or simply use our cf-client to interact with your devices from the command line.</p><a class="btn btn-default" href=https://github.com/eclipse/californium.tools role=button>Repository &raquo;</a></div><!-- /.col-lg-2 --><div class="col-sm-6 col-lg-3 item"><img src=images/e1bfbf57.connector.jpg alt="Connector sources" style="width: 128px; height: 90px; margin-top: 38px"><h2>Connector</h2><p>The element-connector abstracts from the different transports CoAP can use. It provides the basic UDPConnector as well as the interface to implement new connectors like the DtlsConnector of Scandium.</p><a class="btn btn-default" href=https://github.com/eclipse/californium.element-connector role=button>Repository &raquo;</a></div><!-- /.col-lg-2 --></div><!-- /.row --></div><!-- Featurettes ================================================== --><a name=start></a><hr class=featurette-divider><div class="row featurette"><div class=col-md-7><h2 class=featurette-heading>Getting started. <span class=text-muted>Take the tutorial.</span></h2><p class=lead>The Internet of Things if growing, but how can you build your own connected objects? Together with MQTT, CoAP is one of the popular IoT protocols. It provides answers to the typical IoT constraints: it is bandwidth efficient and fits in constrained embedded environment while providing friendly and discoverable RESTful API.</p></div><div class=col-md-5><a href=http://goo.gl/LLQ03w><img class="featurette-image img-responsive" src=images/d46a1065.tutorial.jpg alt="Tutorial slides"></a></div></div><a name=tools></a><hr class=featurette-divider><div class="row featurette"><div class=col-md-5><a href="https://addons.mozilla.org/en-US/firefox/addon/copper-270430/"><img class="featurette-image img-responsive" src=images/boxes/da6cde86.Cu_box_512.png alt="More CoAP tools"></a></div><div class=col-md-7><h2 class=featurette-heading>More tools. <span class=text-muted>Get the full CoAP experience.</span></h2><p class=lead>The Copper (Cu) CoAP user-agent is an add-on for the Firefox Web browser. It allows browsing, bookmarking, and direct interaction with CoAP resources. Simply enter a CoAP URI into the address bar. To get started you can test the following CoAP sandboxes:</p><ul><li><a href="coap://iot.eclipse.org/">coap://iot.eclipse.org/</a></li><li><a href="coap://iot.eclipse.org/">coap://vs0.inf.ethz.ch/</a></li><li><a href="coap://iot.eclipse.org/">coap://coap.me/</a></li></ul><p class=lead>Check <a href=http://coap.technology>coap.technology</a> for more material.</p></div></div></div><div class=footer><div class=container><div class=row><div class="col-xs-12 col-sm-6 col-md-3 col-lg-3 hidden-print"><h2>Eclipse Foundation</h2><ul class=nav><li><a href="//www.eclipse.org/org/">About us</a></li><li><a href=//www.eclipse.org/org/foundation/contact.php>Contact Us</a></li><li><a href=//www.eclipse.org/donate>Donate</a></li><li><a href="//www.eclipse.org/org/documents/">Governance</a></li><li><a href="//www.eclipse.org/artwork/">Logo and Artwork</a></li><li><a href=//www.eclipse.org/org/foundation/directors.php>Board of Directors</a></li></ul></div><div class="col-xs-12 col-sm-6 col-md-3 col-lg-3 hidden-print"><h2>Legal</h2><ul class=nav><li><a href=//www.eclipse.org/legal/privacy.php>Privacy Policy</a></li><li><a href=//www.eclipse.org/legal/termsofuse.php>Terms of Use</a></li><li><a href=//www.eclipse.org/legal/copyright.php>Copyright Agent</a></li><li><a href=//www.eclipse.org/org/documents/epl-v10.php>Eclipse Public License</a></li><li><a href="//www.eclipse.org/legal/">Legal Resources</a></li></ul></div><div class="col-xs-12 col-sm-6 col-md-3 col-lg-3 hidden-print"><h2>Useful Links</h2><ul class=nav><li><a href="//bugs.eclipse.org/bugs/">Report a Bug</a></li><li><a href="//help.eclipse.org/">Documentation</a></li><li><a href="//www.eclipse.org/contribute/">How to Contribute</a></li><li><a href="//www.eclipse.org/mail/">Mailing Lists</a></li><li><a href="//www.eclipse.org/forums/">Forums</a></li><li><a href=//marketplace.eclipse.org>Marketplace</a></li></ul></div><div class="col-xs-12 col-sm-6 col-md-3 col-lg-3 hidden-print"><h2>Other</h2><ul class=nav><li><a href="//www.eclipse.org/ide/">IDE and Tools</a></li><li><a href=//www.eclipse.org/projects>Community of Projects</a></li><li><a href="//www.eclipse.org/org/workinggroups/">Working Groups</a></li></ul></div><div id=copyright class="col-xs-12 col-sm-12 col-md-12 col-lg-12 hidden-print"><div><span class=hidden-print><img src=http://projects.eclipse.org/sites/all/themes/solstice/public/images/logo/eclipse-logo-bw-800x188.png alt="Eclipse.org black and white logo" width=166 height=39 class=logo-eclipse-white></span><p id=copyright-text>Copyright &copy; 2014 The Eclipse Foundation. All Rights Reserved.</p></div></div></div></div></div><!-- Place this tag after the last +1 button tag. --><script type=text/javascript>(function() {
+			var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
+			po.src = 'https://apis.google.com/js/plusone.js';
+			var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
+			})();</script><!-- Google Analytics: change UA-XXXXX-X to be your site's ID. --><script>(function(b,o,i,l,e,r){b.GoogleAnalyticsObject=l;b[l]||(b[l]=
+			function(){(b[l].q=b[l].q||[]).push(arguments)});b[l].l=+new Date;
+			e=o.createElement(i);r=o.getElementsByTagName(i)[0];
+			e.src='//www.google-analytics.com/analytics.js';
+			r.parentNode.insertBefore(e,r)}(window,document,'script','ga'));
+			ga('create','UA-XXXXX-X');ga('send','pageview');</script><script src=scripts/3ef39fab.vendor.js></script><script src=scripts/36cb0375.main.js></script>
\ No newline at end of file
diff --git a/scripts/36cb0375.main.js b/scripts/36cb0375.main.js
new file mode 100644
index 0000000..e21cf83
--- /dev/null
+++ b/scripts/36cb0375.main.js
@@ -0,0 +1 @@
+$(".carousel").carousel({interval:8e3}),$(function(){$.scrollUp({scrollName:"scrollUp",scrollDistance:450,scrollFrom:"top",scrollSpeed:300,easingType:"linear",animation:"fade",animationSpeed:200,scrollTrigger:!1,scrollTarget:!1,scrollText:"Scroll to top",scrollTitle:!1,scrollImg:!0,activeOverlay:!1,zIndex:2147483647})});
\ No newline at end of file
diff --git a/scripts/73b35626.main.js b/scripts/73b35626.main.js
deleted file mode 100644
index 21976a7..0000000
--- a/scripts/73b35626.main.js
+++ /dev/null
@@ -1 +0,0 @@
-$(function(){$.scrollUp({scrollName:"scrollUp",scrollDistance:450,scrollFrom:"top",scrollSpeed:300,easingType:"linear",animation:"fade",animationSpeed:200,scrollTrigger:!1,scrollTarget:!1,scrollText:"Scroll to top",scrollTitle:!1,scrollImg:!0,activeOverlay:!1,zIndex:2147483647})});
\ No newline at end of file
diff --git a/styles/81ae7ec5.main.css b/styles/f5629f8c.main.css
similarity index 67%
rename from styles/81ae7ec5.main.css
rename to styles/f5629f8c.main.css
index 4c9095c..499b854 100644
--- a/styles/81ae7ec5.main.css
+++ b/styles/f5629f8c.main.css
@@ -1 +1 @@
-@media (max-width:991px){.footer #copyright-text,.footer #footer-other{text-align:left;clear:both}}@media (max-width:450px){.footer .col-xs-11,.footer .col-xs-14{position:relative;float:left;width:95.83333333%;min-height:1px;padding-left:15px;padding-right:15px}}@media (min-width:451px) and (max-width:767px){.footer #footer-useful-links{clear:left}.footer #copyright{clear:both}}@media screen and (min-width:768px){.container{max-width:1024px}.footer,.header,.marketing{padding-left:0;padding-right:0}.header{margin-bottom:30px}.jumbotron{border-bottom:0}}.browsehappy{margin:.2em 0;background:#ccc;color:#000;padding:.2em 0}body{padding-top:50px;padding-bottom:0;min-width:320px}.footer,.header,.marketing{padding-left:15px;padding-right:15px}.header{border-bottom:1px solid #e5e5e5}.navbar-brand{width:50px;font-size:0;background:url(../images/logos/20817c7d.Cf_32.png) 9px 9px no-repeat}.navbar-brand2{width:54px;font-size:0;border-top:2px solid transparent;margin-bottom:-2px;background:url(http://iot.eclipse.org/css/img/m2m_eclipse_logo.png) -36px 0 no-repeat}.navbar-nav>li>a:focus,.navbar-nav>li>a:hover{border-top:2px solid #eee;padding-top:13px}.header h3{margin-top:0;margin-bottom:0;line-height:40px;padding-bottom:19px}.footer{background:url(http://projects.eclipse.org/sites/all/themes/solstice/public/images/template/footer-bg.jpg) no-repeat center center #242426;-webkit-background-size:cover;-moz-background-size:cover;-o-background-size:cover;background-size:cover;color:#a8a7a9;margin-top:45px;padding-top:35px;padding-bottom:36px;border-top:1px solid #E5E5E5}.footer h1{padding-top:.5em;padding-bottom:.7em;color:#737373;font-size:2em}.footer h1 strong{color:#C4C4C4}.footer h2{color:#fff;padding-bottom:7px;margin-top:0;font-size:2rem;font-weight:300;border-bottom:2px solid #6e6d71;max-width:80%}.footer a:active,.footer a:link,.footer a:visited{color:#a8a7a9;font-weight:400}.footer #logo-eclipse-white{margin-bottom:15px}.footer .nav{margin-left:-15px;margin-bottom:25px}.footer .nav a{padding:6px 15px 6px 20px}.footer .nav a:hover{background:0 0;color:#f7941e}.footer li{padding-bottom:0}@media (max-width:991px){.footer #copyright-text,.footer #footer-other{text-align:left;clear:both}}@media (max-width:450px){.footer .col-xs-11,.footer .col-xs-14{position:relative;float:left;width:95.83333333%;min-height:1px;padding-left:15px;padding-right:15px}}@media (min-width:451px) and (max-width:767px){.footer #footer-useful-links{clear:left}.footer #copyright{clear:both}}#copyright{padding-top:15px}#copyright img{float:left;margin-top:10px;margin-right:15px;clear:both}#copyright-text{padding-top:21px;text-align:right}#scrollUp{width:40px;height:40px;opacity:.3;position:fixed;bottom:50px;right:15px;display:none;text-indent:-9999px;background:url(http://projects.eclipse.org/sites/all/themes/solstice/public/images/components/back-to-top/back-to-top.png) no-repeat}#scrollUp:focus{outline:0}.carousel-inner .item{min-height:400px;height:400px}.java .carousel-caption{top:25%;bottom:auto}div.item.java{background-image:url(../images/background/0dd7f7a1.java.jpg);background-position:center center}.java h1{text-align:left;color:orange}.java p{text-align:left;color:#000;width:50%;min-width:180px}div.item.cloud{background-image:url(../images/background/b14ea35e.scalable.jpg);background-position:center center}.cloud h1{text-align:left;color:orange}.cloud p{text-align:left}div.item.ietf{background-image:url(../images/background/59a05c7c.compliant.jpg);background-position:center center}.ietf .carousel-caption{top:0;bottom:auto}.ietf h1,.ietf p{text-align:left;color:#000}.marketing{margin:40px 0}.marketing .col-lg-2,.marketing .col-lg-4{margin-bottom:20px;text-align:center}.featurette-divider{margin:80px 0}.featurette-heading{font-weight:300;line-height:1;letter-spacing:-1px}@media screen and (min-width:768px){.container{max-width:1024px}.footer,.header,.marketing{padding-left:0;padding-right:0}.header{margin-bottom:30px}.jumbotron{border-bottom:0}}
\ No newline at end of file
+@media (max-width:991px){.footer #copyright-text,.footer #footer-other{text-align:left;clear:both}}@media (max-width:450px){.footer .col-xs-11,.footer .col-xs-14{position:relative;float:left;width:95.83333333%;min-height:1px;padding-left:15px;padding-right:15px}}@media (min-width:451px) and (max-width:767px){.footer #footer-useful-links{clear:left}.footer #copyright{clear:both}}@media screen and (min-width:768px){.container{max-width:1280px}.footer,.header,.marketing{padding-left:0;padding-right:0}.header{margin-bottom:30px}.jumbotron{border-bottom:0}}.browsehappy{margin:.2em 0;background:#ccc;color:#000;padding:.2em 0}body{padding-top:50px;padding-bottom:0;min-width:320px}.footer,.header,.marketing{padding-left:15px;padding-right:15px}.header{border-bottom:1px solid #e5e5e5}.navbar{min-height:60px;background-color:#121320;border:none;padding:0 0 0 40px}.navbar-brand{width:60px;height:60px;font-size:0;background:url(../images/logos/4812bfce.Cf_48.png) 0 6px no-repeat}.navbar-brand2{width:54px;font-size:0;background:url(http://iot.eclipse.org/css/img/m2m_eclipse_logo.png) -36px 5px no-repeat}a{color:#4b7d38}a:focus{outline-width:thin;outline-style:dotted;outline-color:#333;outline-offset:-2px}a:active,a:hover{outline-width:0;outline-style:none}a:hover{color:#6bb151}.nav>li>a{display:block}.nav>li>a:hover{background-color:#eee}.navbar .nav>li>a{float:none;padding-top:20px;padding-right:15px;padding-bottom:20px;padding-left:15px;color:#c4c6dd;text-shadow:#161726;border-top-width:2px;border-top-style:solid;border-top-color:#161726}.navbar .nav>li>a:focus,.navbar .nav>li>a:hover{color:#eff4f7;background-color:transparent;border-top-color:#eff4f7}.header h3{margin-top:0;margin-bottom:0;line-height:40px;padding-bottom:19px}.footer{background:url(http://projects.eclipse.org/sites/all/themes/solstice/public/images/template/footer-bg.jpg) no-repeat center center #242426;-webkit-background-size:cover;-moz-background-size:cover;-o-background-size:cover;background-size:cover;color:#a8a7a9;margin-top:45px;padding-top:35px;padding-bottom:36px;border-top:1px solid #E5E5E5}.footer h1{padding-top:.5em;padding-bottom:.7em;color:#737373;font-size:2em}.footer h1 strong{color:#C4C4C4}.footer h2{color:#fff;padding-bottom:7px;margin-top:0;font-size:2rem;font-weight:300;border-bottom:2px solid #6e6d71;max-width:80%}.footer a:active,.footer a:link,.footer a:visited{color:#a8a7a9;font-weight:400}.footer #logo-eclipse-white{margin-bottom:15px}.footer .nav{margin-left:-15px;margin-bottom:25px}.footer .nav a{padding:6px 15px 6px 20px}.footer .nav a:hover{background:0 0;color:#f7941e}.footer li{padding-bottom:0}@media (max-width:991px){.footer #copyright-text,.footer #footer-other{text-align:left;clear:both}}@media (max-width:450px){.footer .col-xs-11,.footer .col-xs-14{position:relative;float:left;width:95.83333333%;min-height:1px;padding-left:15px;padding-right:15px}}@media (min-width:451px) and (max-width:767px){.footer #footer-useful-links{clear:left}.footer #copyright{clear:both}}#copyright{padding-top:15px}#copyright img{float:left;margin-top:10px;margin-right:15px;clear:both}#copyright-text{padding-top:21px;text-align:right}#scrollUp{width:40px;height:40px;opacity:.3;position:fixed;bottom:50px;right:15px;display:none;text-indent:-9999px;background:url(http://projects.eclipse.org/sites/all/themes/solstice/public/images/components/back-to-top/back-to-top.png) no-repeat}#scrollUp:focus{outline:0}.carousel-inner .item{min-height:400px;height:400px}.java .carousel-caption{top:25%;bottom:auto}div.item.java{background-image:url(../images/background/0dd7f7a1.java.jpg);background-position:center center}.java h1{text-align:left;color:orange}.java p{text-align:left;color:#000;width:50%;min-width:180px}div.item.cloud{background-image:url(../images/background/b14ea35e.scalable.jpg);background-position:center center}.cloud h1{text-align:left;color:orange}.cloud p{text-align:left}div.item.ietf{background-image:url(../images/background/59a05c7c.compliant.jpg);background-position:center center}.ietf .carousel-caption{top:0;bottom:auto}.ietf h1,.ietf p{text-align:left;color:#000}.marketing{margin:40px 0}.marketing .item{margin-bottom:40px;text-align:center}.marketing .item p{text-align:justify;margin:10px}.featurette-divider{margin:80px 0}.featurette-heading{font-weight:300;line-height:1;letter-spacing:-1px}@media screen and (min-width:768px){.container{max-width:1280px}.footer,.header,.marketing{padding-left:0;padding-right:0}.header{margin-bottom:30px}.jumbotron{border-bottom:0}}
\ No newline at end of file
