diff --git a/configure.ac b/configure.ac
index 89e0760..4309bd0 100644
--- a/configure.ac
+++ b/configure.ac
@@ -39,7 +39,7 @@ AC_CHECK_FUNCS(getopt_long gettimeofday strcspn strdup strtod)
 
 # Checks for GTK+ libraries.
 #
-AM_PATH_GTK_2_0(2.0.1, , AC_MSG_ERROR([Cannot find proper GTK+ version]))
+PKG_CHECK_MODULES([GTK], [gtk+-3.0])
 
 #
 # Check for OpenGL libraries
@@ -71,11 +71,7 @@ if test -n "$with_gtkgl_prefix" ; then
 	GTKGL_LDOPTS="-L$with_gtkgl_prefix/lib"
 fi
 
-AC_CHECK_LIB(gtkgl-2.0, gtk_gl_area_new, ,
-	AC_MSG_ERROR([Cannot find GtkGLArea library.]),
-	$GTKGL_LDOPTS $GTK_LIBS $GL_LIBS)
-
-GTKGL_LIBS="$GTKGL_LDOPTS -lgtkgl-2.0"
+GTKGL_LIBS="$GTKGL_LDOPTS"
 
 #
 # Test for libpng
diff --git a/src/gtkwidgets.c b/src/gtkwidgets.c
index 01739d0..6ffc00f 100644
--- a/src/gtkwidgets.c
+++ b/src/gtkwidgets.c
@@ -41,18 +41,18 @@ add_gl_area( GtkWidget *parent_box_w )
 	                       GDK_BUTTON2_MOTION_MASK | GDK_BUTTON3_MOTION_MASK |
 	                       GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK );
 	/* Attach the signal handlers */
-	gtk_signal_connect( GTK_OBJECT(ogl_w), "realize",
-	                    GTK_SIGNAL_FUNC(ogl_initialize), NULL );
-	gtk_signal_connect( GTK_OBJECT(ogl_w), "expose_event",
-	                    GTK_SIGNAL_FUNC(ogl_refresh), NULL );
-	gtk_signal_connect( GTK_OBJECT(ogl_w), "configure_event",
-	                    GTK_SIGNAL_FUNC(ogl_resize), NULL );
-	gtk_signal_connect( GTK_OBJECT(ogl_w), "button_press_event",
-	                    GTK_SIGNAL_FUNC(camera_move), NULL );
-	gtk_signal_connect( GTK_OBJECT(ogl_w), "button_release_event",
-	                    GTK_SIGNAL_FUNC(camera_move), NULL );
-	gtk_signal_connect( GTK_OBJECT(ogl_w), "motion_notify_event",
-	                    GTK_SIGNAL_FUNC(camera_move), NULL );
+	g_signal_connect( G_OBJECT(ogl_w), "realize",
+	                    G_CALLBACK(ogl_initialize), NULL );
+	g_signal_connect( G_OBJECT(ogl_w), "draw",
+	                    G_CALLBACK(ogl_refresh), NULL );
+	g_signal_connect( G_OBJECT(ogl_w), "configure_event",
+	                    G_CALLBACK(ogl_resize), NULL );
+	g_signal_connect( G_OBJECT(ogl_w), "button_press_event",
+	                    G_CALLBACK(camera_move), NULL );
+	g_signal_connect( G_OBJECT(ogl_w), "button_release_event",
+	                    G_CALLBACK(camera_move), NULL );
+	g_signal_connect( G_OBJECT(ogl_w), "motion_notify_event",
+	                    G_CALLBACK(camera_move), NULL );
 
 	return ogl_w;
 }
@@ -68,8 +68,8 @@ make_dialog_window( const char *title, void *callback_close )
 	gtk_window_set_title( GTK_WINDOW(dialog_window_w), title );
 	gtk_container_set_border_width( GTK_CONTAINER(dialog_window_w), 0 );
 	if (callback_close != NULL) {
-		gtk_signal_connect( GTK_OBJECT(dialog_window_w), "destroy",
-		                    GTK_SIGNAL_FUNC(callback_close), MESG_(DIALOG_CLOSE) );
+		g_signal_connect( G_OBJECT(dialog_window_w), "destroy",
+		                    G_CALLBACK(callback_close), MESG_(DIALOG_CLOSE) );
 	}
 	/* Note, no gtk_widget_show( ) */
 
@@ -89,8 +89,8 @@ message_window( const char *title, const char *message_text )
 
 	message_window_w = make_dialog_window( title, NULL );
 	gtk_window_set_position( GTK_WINDOW(message_window_w), GTK_WIN_POS_MOUSE );
-	gtk_signal_connect( GTK_OBJECT(message_window_w), "delete_event",
-	                    GTK_SIGNAL_FUNC(gtk_widget_destroy), NULL );
+	g_signal_connect( G_OBJECT(message_window_w), "delete_event",
+	                    G_CALLBACK(gtk_widget_destroy), NULL );
 	vbox_w = add_vbox( message_window_w, FALSE, 10 );
 	frame_w = add_frame( vbox_w, NULL );
 	hbox_w = add_hbox( frame_w, FALSE, 10 );
@@ -100,8 +100,8 @@ message_window( const char *title, const char *message_text )
 	button_w = gtk_button_new( );
 	add_label( button_w, "OK" );
 	gtk_box_pack_start( GTK_BOX(vbox_w), button_w, TRUE, TRUE, 0 );
-	gtk_signal_connect_object( GTK_OBJECT(button_w), "clicked",
-	                           GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(message_window_w) );
+	g_signal_connect_swapped( G_OBJECT(button_w), "clicked",
+	                           G_CALLBACK(gtk_widget_destroy), G_OBJECT(message_window_w) );
 	gtk_widget_show( button_w );
 
 	gtk_widget_show( message_window_w );
@@ -122,8 +122,8 @@ confirmation_dialog( const char *title, const char *message_text, void *callback
 
 	confirm_window_w = make_dialog_window( title, callback );
 	gtk_window_set_position( GTK_WINDOW(confirm_window_w), GTK_WIN_POS_MOUSE );
-	gtk_signal_connect( GTK_OBJECT(confirm_window_w), "delete_event",
-	                    GTK_SIGNAL_FUNC(gtk_widget_destroy), NULL );
+	g_signal_connect( G_OBJECT(confirm_window_w), "delete_event",
+	                    G_CALLBACK(gtk_widget_destroy), NULL );
 	main_vbox_w = add_vbox( confirm_window_w, FALSE, 10 );
 	frame_w = add_frame( main_vbox_w, NULL );
 	hbox_w = add_hbox( frame_w, FALSE, 10 );
@@ -134,12 +134,12 @@ confirmation_dialog( const char *title, const char *message_text, void *callback
 	button_w = gtk_button_new( );
 	add_label( button_w, "OK" );
 	gtk_box_pack_start( GTK_BOX(hbox_w), button_w, TRUE, TRUE, 0 );
-	gtk_signal_connect_object( GTK_OBJECT(button_w), "clicked",
-	                           GTK_SIGNAL_FUNC(gtk_widget_hide), GTK_OBJECT(confirm_window_w) );
-	gtk_signal_connect( GTK_OBJECT(button_w), "clicked",
-	                    GTK_SIGNAL_FUNC(callback), MESG_(DIALOG_OK_CONFIRM) );
-	gtk_signal_connect_object( GTK_OBJECT(button_w), "clicked",
-	                           GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(confirm_window_w) );
+	g_signal_connect_swapped( G_OBJECT(button_w), "clicked",
+	                           G_CALLBACK(gtk_widget_hide), G_OBJECT(confirm_window_w) );
+	g_signal_connect( G_OBJECT(button_w), "clicked",
+	                    G_CALLBACK(callback), MESG_(DIALOG_OK_CONFIRM) );
+	g_signal_connect_swapped( G_OBJECT(button_w), "clicked",
+	                           G_CALLBACK(gtk_widget_destroy), G_OBJECT(confirm_window_w) );
 	gtk_widget_show( button_w );
 
 	add_hbox( hbox_w, TRUE, 0 ); /* spacer */
@@ -148,12 +148,12 @@ confirmation_dialog( const char *title, const char *message_text, void *callback
 	button_w = gtk_button_new( );
 	add_label( button_w, "Cancel" );
 	gtk_box_pack_start( GTK_BOX(hbox_w), button_w, TRUE, TRUE, 0 );
-	gtk_signal_connect_object( GTK_OBJECT(button_w), "clicked",
-	                           GTK_SIGNAL_FUNC(gtk_widget_hide), GTK_OBJECT(confirm_window_w) );
-	gtk_signal_connect( GTK_OBJECT(button_w), "clicked",
-	                    GTK_SIGNAL_FUNC(callback), MESG_(DIALOG_CLOSE) );
-	gtk_signal_connect_object( GTK_OBJECT(button_w), "clicked",
-	                           GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(confirm_window_w) );
+	g_signal_connect_swapped( G_OBJECT(button_w), "clicked",
+	                           G_CALLBACK(gtk_widget_hide), G_OBJECT(confirm_window_w) );
+	g_signal_connect( G_OBJECT(button_w), "clicked",
+	                    G_CALLBACK(callback), MESG_(DIALOG_CLOSE) );
+	g_signal_connect_swapped( G_OBJECT(button_w), "clicked",
+	                           G_CALLBACK(gtk_widget_destroy), G_OBJECT(confirm_window_w) );
 	gtk_widget_show( button_w );
 
 	gtk_widget_show( confirm_window_w );
@@ -162,28 +162,6 @@ confirmation_dialog( const char *title, const char *message_text, void *callback
 }
 
 
-/* Creates a file selection dialog */
-GtkWidget *
-make_filesel_window( const char *title, const char *init_filename, int show_fileops, void *callback_handler )
-{
-	GtkWidget *filesel_w;
-
-	filesel_w = gtk_file_selection_new( title );
-	if (!show_fileops)
-		gtk_file_selection_hide_fileop_buttons( GTK_FILE_SELECTION(filesel_w) );
-	if (init_filename != NULL)
-		gtk_file_selection_set_filename( GTK_FILE_SELECTION(filesel_w), init_filename );
-	gtk_signal_connect( GTK_OBJECT(filesel_w), "destroy",
-	                    GTK_SIGNAL_FUNC(callback_handler), MESG_(DIALOG_CLOSE) );
-	gtk_signal_connect( GTK_OBJECT(GTK_FILE_SELECTION(filesel_w)->cancel_button),
-	                    "clicked", GTK_SIGNAL_FUNC(callback_handler), MESG_(DIALOG_CLOSE) );
-	gtk_signal_connect( GTK_OBJECT(GTK_FILE_SELECTION(filesel_w)->ok_button),
-	                    "clicked", GTK_SIGNAL_FUNC(callback_handler), MESG_(DIALOG_OK) );
-
-	return filesel_w;
-}
-
-
 /* Add a menu to a menu bar (or a submenu to a menu) */
 GtkWidget *
 add_menu( GtkWidget *parent_menu_w, const char *label )
@@ -192,11 +170,7 @@ add_menu( GtkWidget *parent_menu_w, const char *label )
 	GtkWidget *menu_w;
 
 	menu_item_w = gtk_menu_item_new_with_label( label );
-	/* parent_menu can be a menu bar or a regular menu */
-	if (GTK_IS_MENU_BAR(parent_menu_w))
-		gtk_menu_bar_append( GTK_MENU_BAR(parent_menu_w), menu_item_w );
-	else
-		gtk_menu_append( GTK_MENU(parent_menu_w), menu_item_w );
+	gtk_menu_shell_append( GTK_MENU_SHELL(parent_menu_w), menu_item_w );
 	gtk_widget_show( menu_item_w );
 	menu_w = gtk_menu_new( );
 	gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu_item_w), menu_w );
@@ -212,10 +186,10 @@ add_menu_item( GtkWidget *menu_w, const char *label, void *callback, void *callb
 	GtkWidget *menu_item_w;
 
 	menu_item_w = gtk_menu_item_new_with_label( label );
-	gtk_menu_append( GTK_MENU(menu_w), menu_item_w );
+	gtk_menu_shell_append( GTK_MENU_SHELL(menu_w), menu_item_w );
 	if (callback != NULL) {
-		gtk_signal_connect( GTK_OBJECT(menu_item_w), "activate",
-		                    GTK_SIGNAL_FUNC(callback), callback_data );
+		g_signal_connect( G_OBJECT(menu_item_w), "activate",
+		                    G_CALLBACK(callback), callback_data );
 	}
 	gtk_widget_show( menu_item_w );
 
@@ -231,10 +205,11 @@ add_check_menu_item( GtkWidget *menu_w, const char *label, int init_state, void
 
 	chkmenu_item_w = gtk_check_menu_item_new_with_label( label );
 	gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(chkmenu_item_w), init_state );
-	gtk_check_menu_item_set_show_toggle( GTK_CHECK_MENU_ITEM(chkmenu_item_w), TRUE );
-	gtk_menu_append( GTK_MENU(menu_w), chkmenu_item_w );
-	gtk_signal_connect( GTK_OBJECT(chkmenu_item_w), "toggled",
-	                    GTK_SIGNAL_FUNC(callback), callback_data );
+	/*TODO: Looks like the next call is unnecessary in GTK3 but better check */
+	// gtk_check_menu_item_set_show_toggle( GTK_CHECK_MENU_ITEM(chkmenu_item_w), TRUE );
+	gtk_menu_shell_append( GTK_MENU_SHELL(menu_w), chkmenu_item_w );
+	g_signal_connect( G_OBJECT(chkmenu_item_w), "toggled",
+	                    G_CALLBACK(callback), callback_data );
 	gtk_widget_show( chkmenu_item_w );
 
 	return chkmenu_item_w;
@@ -262,12 +237,12 @@ add_radio_menu_item( GtkWidget *menu_w, const char *label, void *callback, void
 
 	if (menu_w != NULL) {
 		radmenu_item_w = gtk_radio_menu_item_new_with_label( radio_group, label );
-		radio_group = gtk_radio_menu_item_group( GTK_RADIO_MENU_ITEM(radmenu_item_w) );
-		gtk_menu_append( GTK_MENU(menu_w), radmenu_item_w );
+		radio_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(radmenu_item_w) );
+		gtk_menu_shell_append( GTK_MENU_SHELL(menu_w), radmenu_item_w );
 		if (radmenu_item_num == init_selected)
 			gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(radmenu_item_w), TRUE );
-		gtk_signal_connect( GTK_OBJECT(radmenu_item_w), "toggled",
-		                    GTK_SIGNAL_FUNC(callback), callback_data );
+		g_signal_connect( G_OBJECT(radmenu_item_w), "toggled",
+		                    G_CALLBACK(callback), callback_data );
 		gtk_widget_show( radmenu_item_w );
 		++radmenu_item_num;
 	}
@@ -285,6 +260,8 @@ add_radio_menu_item( GtkWidget *menu_w, const char *label, void *callback, void
 /* Option menu definiton
  * Call this however many times necessary, and then call add_option_menu( )
  * to stick in the finished widget */
+ /*TODO: Possibly this isn't needed in GTK3 any more */
+/*
 GtkWidget *
 option_menu_item( const char *label, void *callback, void *callback_data )
 {
@@ -292,41 +269,14 @@ option_menu_item( const char *label, void *callback, void *callback_data )
 
 	menu_item_w = gtk_menu_item_new_with_label( label );
 	if (callback != NULL) {
-		gtk_signal_connect( GTK_OBJECT(menu_item_w), "activate",
-		                    GTK_SIGNAL_FUNC(callback), callback_data );
+		g_signal_connect( G_OBJECT(menu_item_w), "activate",
+		                    G_CALLBACK(callback), callback_data );
 	}
 	add_option_menu( menu_item_w );
 
 	return menu_item_w;
 }
-
-
-/* Add the finished option menu into the specified box widget
- * (widget can only be a menu item when called from option_menu_item( )) */
-GtkWidget *
-add_option_menu( GtkWidget *widget )
-{
-	static GtkWidget *menu_w = NULL;
-	GtkWidget *optmenu_w;
-
-	if (GTK_IS_MENU_ITEM(widget)) {
-		if (menu_w == NULL)
-			menu_w = gtk_menu_new( );
-		gtk_menu_append( GTK_MENU(menu_w), widget );
-		gtk_widget_show( widget );
-		return NULL;
-	}
-
-	/* widget is a Gtk?box */
-	optmenu_w = gtk_option_menu_new( );
-	gtk_option_menu_set_menu( GTK_OPTION_MENU(optmenu_w), menu_w );
-	gtk_box_pack_start( GTK_BOX(widget), optmenu_w, FALSE, FALSE, 0 );
-	gtk_widget_show( optmenu_w );
-	menu_w = NULL;
-
-	return optmenu_w;
-}
-
+*/
 
 /* The ever-ubiquitous separator */
 void
@@ -336,10 +286,10 @@ add_separator( GtkWidget *parent_w )
 
 	if (GTK_IS_MENU(parent_w)) {
 		separator_w = gtk_menu_item_new( );
-		gtk_menu_append( GTK_MENU(parent_w), separator_w );
+		gtk_menu_shell_append( GTK_MENU_SHELL(parent_w), separator_w );
 	}
 	else {
-		separator_w = gtk_hseparator_new( );
+		separator_w = gtk_separator_new( GTK_ORIENTATION_HORIZONTAL );
 		gtk_box_pack_start( GTK_BOX(parent_w), separator_w, TRUE, TRUE, 0 );
 	}
 	gtk_widget_show( separator_w );
@@ -399,7 +349,7 @@ add_hbox( GtkWidget *parent_w, int homog, int spacing )
 {
 	GtkWidget *hbox_w;
 
-	hbox_w = gtk_hbox_new( homog, spacing );
+	hbox_w = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, spacing );
 	gtk_container_set_border_width( GTK_CONTAINER(hbox_w), spacing );
 	if (GTK_IS_BOX(parent_w))
 		gtk_box_pack_start( GTK_BOX(parent_w), hbox_w, FALSE, FALSE, 0 );
@@ -417,7 +367,7 @@ add_vbox( GtkWidget *parent_w, int homog, int spacing )
 {
 	GtkWidget *vbox_w;
 
-	vbox_w = gtk_vbox_new( homog, spacing );
+	vbox_w = gtk_box_new( GTK_ORIENTATION_VERTICAL, spacing );
 	gtk_container_set_border_width( GTK_CONTAINER(vbox_w), spacing );
 	if (GTK_IS_BOX(parent_w))
 		gtk_box_pack_start( GTK_BOX(parent_w), vbox_w, FALSE, FALSE, 0 );
@@ -450,11 +400,11 @@ add_frame( GtkWidget *parent_w, const char *title )
 
 /* The horizontal value slider widget */
 GtkWidget *
-add_hscale( GtkWidget *parent_w, GtkObject *adjustment )
+add_hscale( GtkWidget *parent_w, GObject *adjustment )
 {
 	GtkWidget *hscale_w;
 
-	hscale_w = gtk_hscale_new( GTK_ADJUSTMENT(adjustment) );
+	hscale_w = gtk_scale_new( GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(adjustment) );
 	gtk_scale_set_digits( GTK_SCALE(hscale_w), 0 );
 	if (GTK_IS_BOX(parent_w))
 		gtk_box_pack_start( GTK_BOX(parent_w), hscale_w, TRUE, TRUE, 0 );
@@ -468,11 +418,11 @@ add_hscale( GtkWidget *parent_w, GtkObject *adjustment )
 
 /* The vertical value slider widget */
 GtkWidget *
-add_vscale( GtkWidget *parent_w, GtkObject *adjustment )
+add_vscale( GtkWidget *parent_w, GObject *adjustment )
 {
 	GtkWidget *vscale_w;
 
-	vscale_w = gtk_vscale_new( GTK_ADJUSTMENT(adjustment) );
+	vscale_w = gtk_scale_new( GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT(adjustment) );
 	gtk_scale_set_value_pos( GTK_SCALE(vscale_w), GTK_POS_RIGHT );
 	gtk_scale_set_digits( GTK_SCALE(vscale_w), 0 );
 	if (GTK_IS_BOX(parent_w))
@@ -487,7 +437,7 @@ add_vscale( GtkWidget *parent_w, GtkObject *adjustment )
 
 /* The spin button widget */
 GtkWidget *
-add_spin_button( GtkWidget *parent_w, GtkObject *adjustment )
+add_spin_button( GtkWidget *parent_w, GObject *adjustment )
 {
 	GtkWidget *spin_button_w;
 
@@ -516,8 +466,8 @@ add_check_button( GtkWidget *parent_w, const char *label, int init_state, void *
 	else
 		gtk_container_add( GTK_CONTAINER(parent_w), chkbutton_w );
 	if (callback != NULL) {
-		gtk_signal_connect( GTK_OBJECT(chkbutton_w), "toggled",
-		                    GTK_SIGNAL_FUNC(callback), callback_data );
+		g_signal_connect( G_OBJECT(chkbutton_w), "toggled",
+		                    G_CALLBACK(callback), callback_data );
 	}
 	gtk_widget_show( chkbutton_w );
 
@@ -531,15 +481,16 @@ add_entry( GtkWidget *parent_w, const char *init_str, void *callback, void *call
 {
 	GtkWidget *entry_w;
 
-	entry_w = gtk_entry_new_with_max_length( 16 );
+	entry_w = gtk_entry_new();
+	gtk_entry_set_max_length( GTK_ENTRY(entry_w), 16 );
 	if (GTK_IS_BOX(parent_w))
 		gtk_box_pack_start( GTK_BOX(parent_w), entry_w, FALSE, FALSE, 0 );
 	else
 		gtk_container_add( GTK_CONTAINER(parent_w), entry_w );
 	gtk_entry_set_text( GTK_ENTRY(entry_w), init_str );
 	if (callback != NULL )
-		gtk_signal_connect( GTK_OBJECT(entry_w), "activate",
-		                    GTK_SIGNAL_FUNC(callback), callback_data );
+		g_signal_connect( G_OBJECT(entry_w), "activate",
+		                    G_CALLBACK(callback), callback_data );
 	gtk_widget_show( entry_w );
 
 	return entry_w;
@@ -550,13 +501,10 @@ add_entry( GtkWidget *parent_w, const char *init_str, void *callback, void *call
 void
 set_entry_width( GtkWidget *entry_w, const char *span_str )
 {
-	GtkStyle *style;
-	GdkFont *font;
-	int width;
+	gint width;
 
-	style = gtk_widget_get_style( entry_w );
-	width = gdk_string_width( font, span_str );
-	gtk_widget_set_usize( entry_w, width, 0 );
+	width = sizeof(span_str);
+	gtk_entry_set_width_chars( GTK_ENTRY(entry_w), width );
 }
 
 
@@ -580,7 +528,7 @@ read_entry( GtkWidget *entry_w )
 void
 highlight_entry( GtkWidget *entry_w )
 {
-	gtk_entry_select_region( GTK_ENTRY(entry_w), 0, GTK_ENTRY(entry_w)->text_length );
+	gtk_editable_select_region( GTK_EDITABLE(entry_w), 0, -1 );
 }
 
 
@@ -596,8 +544,8 @@ add_button( GtkWidget *parent_w, const char *label, void *callback, void *callba
 		gtk_box_pack_start( GTK_BOX(parent_w), button_w, TRUE, TRUE, 0 );
 	else
 		gtk_container_add( GTK_CONTAINER(parent_w), button_w );
-	gtk_signal_connect( GTK_OBJECT(button_w), "clicked",
-	                    GTK_SIGNAL_FUNC(callback), callback_data );
+	g_signal_connect( G_OBJECT(button_w), "clicked",
+	                    G_CALLBACK(callback), callback_data );
 	gtk_widget_show( button_w );
 
 	return button_w;
@@ -627,6 +575,7 @@ add_label( GtkWidget *parent_w, const char *label_text )
 
 
 /* Adds an XPM */
+/*
 GtkWidget *
 add_pixmap( GtkWidget *parent_w, GtkWidget *parent_window_w, char **xpm_data )
 {
@@ -635,7 +584,7 @@ add_pixmap( GtkWidget *parent_w, GtkWidget *parent_window_w, char **xpm_data )
 	GdkPixmap *pixmap;
 	GdkBitmap *mask;
 
-	/* Realize the window to prevent a "NULL window" error */
+	// Realize the window to prevent a "NULL window" error
 	gtk_widget_realize( parent_window_w );
 	style = gtk_widget_get_style( parent_window_w );
 	pixmap = gdk_pixmap_create_from_xpm_d( parent_window_w->window, &mask,
@@ -648,20 +597,6 @@ add_pixmap( GtkWidget *parent_w, GtkWidget *parent_window_w, char **xpm_data )
 
 	return pixmap_w;
 }
-
-
-/* Associates an XPM icon to a window */
-void assign_icon( GtkWidget *window_w, char **xpm_data )
-{
-	GtkStyle *style;
-	GdkPixmap *icon_pixmap;
-	GdkBitmap *mask;
-
-	gtk_widget_realize( window_w );
-	style = gtk_widget_get_style( window_w );
-	icon_pixmap = gdk_pixmap_create_from_xpm_d( window_w->window, &mask,
-	              &style->bg[GTK_STATE_NORMAL], xpm_data );
-	gdk_window_set_icon( window_w->window, NULL, icon_pixmap, mask );
-}
+*/
 
 /* end gtkwidgets.c */
diff --git a/src/infodisp.c b/src/infodisp.c
index 40c84b2..a2b9592 100644
--- a/src/infodisp.c
+++ b/src/infodisp.c
@@ -90,17 +90,17 @@ info_display( int message1, int message2 )
 
 	if (disp_velocity) {
 		sprintf( disp_str, STR_INF_velocity_ARG, velocity_string( velocity, TRUE ) );
-		ogl_draw_string( disp_str, POS_BOTTOM_LEFT, 2 );
+		/*TODO: Disable for now in GTK3*/ //ogl_draw_string( disp_str, POS_BOTTOM_LEFT, 2 );
 	}
 
 	if (disp_time_t) {
 		sprintf( disp_str, STR_INF_time_ARG, time_string( ) );
-		ogl_draw_string( disp_str, POS_TOP_LEFT, 2 );
+		/*TODO: Disable for now in GTK3*/ //ogl_draw_string( disp_str, POS_TOP_LEFT, 2 );
 	}
 
 	if (disp_gamma) {
 		sprintf( disp_str, STR_INF_gamma_ARG, lorentz_factor( velocity ) );
-		ogl_draw_string( disp_str, POS_BOTTOM_RIGHT, 1 );
+		/*TODO: Disable for now in GTK3*/ //ogl_draw_string( disp_str, POS_BOTTOM_RIGHT, 1 );
 	}
 
 	/* Get status of each of the warp transforms */
@@ -109,6 +109,8 @@ info_display( int message1, int message2 )
 	no_headlight = !warp( QUERY, MESG_(WARP_HEADLIGHT_EFFECT) );
 	no_doppler = !warp( QUERY, MESG_(WARP_DOPPLER_SHIFT) );
 
+	/*TODO: Disable for now in GTK3*/ 
+	/*
 	if (no_contract && no_doppler && no_headlight && no_deform)
 		ogl_draw_string( STR_INF_no_relativity, POS_TOP_RIGHT, 1 );
 	else {
@@ -124,10 +126,10 @@ info_display( int message1, int message2 )
 		if (no_deform)
 			ogl_draw_string( STR_INF_no_deformation, POS_TOP_RIGHT, 0 );
 	}
-
+	*/
 	if (disp_framerate) {
 		sprintf( disp_str, STR_INF_fps_ARG, framerate );
-		ogl_draw_string( disp_str, POS_TOP_RIGHT, 0 );
+		/*TODO: Disable for now in GTK3*/ //ogl_draw_string( disp_str, POS_TOP_RIGHT, 0 );
 	}
 
 	glEnable( GL_LIGHTING );
diff --git a/src/lightspeed.c b/src/lightspeed.c
index e885050..24bc931 100644
--- a/src/lightspeed.c
+++ b/src/lightspeed.c
@@ -130,19 +130,22 @@ main( int argc, char **argv )
 	gtk_init( &argc, &argv );
 
 	/* Check for OpenGL support (GLX extension) */
+	/* TODO: The check is temporarily deactivated as gdk_gl_query does not exist in GTK3 */
+	/*
 	if (gdk_gl_query( ) == FALSE) {
 		fprintf( stderr, "Light Speed! requires OpenGL support to run." );
 		fflush( stderr );
 		return -1;
 	}
-
+	*/
+	
 	/* Generate/load initial object */
 	if (init_obj_file == NULL)
 		make_lattice( DEF_LATTICE_X, DEF_LATTICE_Y, DEF_LATTICE_Z, DEF_LATTICE_SMOOTH );
 	else {
 		i = import_objects( init_obj_file );
 		if (i < 0) {
-			gtk_timeout_add( 5000, (GtkFunction)gtk_main_quit, NULL );
+			g_timeout_add( 5000, (GSourceFunc)gtk_main_quit, NULL );
 			gtk_main( );
 			return -1;
 		}
diff --git a/src/lightspeed.h b/src/lightspeed.h
index 678974e..f9bd1fa 100644
--- a/src/lightspeed.h
+++ b/src/lightspeed.h
@@ -45,7 +45,6 @@
 /* GTK+ */
 #include <gtk/gtk.h>
 #include <gtkgl/gtkglarea.h>
-#include <gtk/gtktext.h>
 #include <gtk/gtkaccelgroup.h>
 
 /* Compile-time settings */
@@ -432,9 +431,9 @@ void keybind( GtkWidget *widget, char *keys );
 GtkWidget *add_hbox( GtkWidget *parent_w, int homog, int spacing );
 GtkWidget *add_vbox( GtkWidget *parent_w, int homog, int spacing );
 GtkWidget *add_frame( GtkWidget *parent_w, const char *title );
-GtkWidget *add_hscale( GtkWidget *parent_w, GtkObject *adjustment );
-GtkWidget *add_vscale( GtkWidget *parent_w, GtkObject *adjustment );
-GtkWidget *add_spin_button( GtkWidget *parent_w, GtkObject *adjustment );
+GtkWidget *add_hscale( GtkWidget *parent_w, GObject *adjustment );
+GtkWidget *add_vscale( GtkWidget *parent_w, GObject *adjustment );
+GtkWidget *add_spin_button( GtkWidget *parent_w, GObject *adjustment );
 GtkWidget *add_check_button( GtkWidget *parent_w, const char *label, int init_state, void *callback, void *callback_data );
 GtkWidget *add_entry( GtkWidget *parent_w, const char *init_str, void *callback, void *callback_data );
 void set_entry_width( GtkWidget *entry_w, const char *span_str );
diff --git a/src/mainwindow.c b/src/mainwindow.c
index c059876..aeee48e 100644
--- a/src/mainwindow.c
+++ b/src/mainwindow.c
@@ -40,20 +40,21 @@ void main_window( void )
 	/* Main window widget */
 	main_window_w = gtk_window_new( GTK_WINDOW_TOPLEVEL );
 	gtk_window_set_title( GTK_WINDOW(main_window_w), STR_Light_Speed );
-	gtk_widget_set_usize( main_window_w, 600, 450 );
+	gtk_widget_set_size_request( main_window_w, 600, 450 );
 	gtk_container_set_border_width( GTK_CONTAINER(main_window_w), 0 );
-	gtk_signal_connect( GTK_OBJECT(main_window_w), "focus_in_event",
-	                    GTK_SIGNAL_FUNC(camera_set_current), NULL );
+	g_signal_connect( G_OBJECT(main_window_w), "focus_in_event",
+	                    G_CALLBACK(camera_set_current), NULL );
 
 	/* Need to set this so assoc_cam_id( ) will work */
 	usr_cams[0]->window_w = main_window_w;
 	usr_cams[0]->ogl_w = NULL; /* for ogl_make_widget( ) */
 
 	/* (and its obligatory kill buttons) */
-	gtk_signal_connect( GTK_OBJECT(main_window_w), "delete_event",
-	                    GTK_SIGNAL_FUNC(gtk_main_quit), NULL );
+	g_signal_connect( G_OBJECT(main_window_w), "delete_event",
+	                    G_CALLBACK(gtk_main_quit), NULL );
 	/* Destroy window before exiting */
-	gtk_quit_add_destroy( 1, GTK_OBJECT(main_window_w) );
+	/*TODO: This doesn't work in GTK3 */
+	//gtk_quit_add_destroy( 1, G_OBJECT(main_window_w) );
 
 	/* Main vertical box widget */
 	main_vbox_w = add_vbox( main_window_w, FALSE, 0 );
@@ -133,7 +134,7 @@ void main_window( void )
 	velocity_input( hbox_w, MESG_(INITIALIZE) );
 
 	/* Horizontal box for viewport and velocity slider */
-	hbox_w = gtk_hbox_new( FALSE, 0 );
+	hbox_w = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 );
 	gtk_box_pack_start( GTK_BOX(main_vbox_w), hbox_w, TRUE, TRUE, 0 );
 	gtk_widget_show( hbox_w );
 
@@ -187,8 +188,8 @@ void add_Camera_menu( GtkWidget *menu_bar_w, GtkWidget *window_w )
 	}
 	add_separator( submenu_w );
 	menu_item_w = add_radio_menu_item( submenu_w, STR_MNU_Custom, dialog_Camera_Lens_Custom, MESG_(DIALOG_OPEN) );
-	gtk_signal_connect( GTK_OBJECT(menu_item_w), "activate",
-	                    GTK_SIGNAL_FUNC(dialog_Camera_Lens_Custom), MESG_(DIALOG_OPEN) );
+	g_signal_connect( G_OBJECT(menu_item_w), "activate",
+	                    G_CALLBACK(dialog_Camera_Lens_Custom), MESG_(DIALOG_OPEN) );
 	/* Lens submenu finished */
 	if (advanced_interface)
 		add_menu_item( menu_w, STR_MNU_Position, dialog_Camera_Position, MESG_(DIALOG_OPEN) );
@@ -230,9 +231,9 @@ void add_Camera_menu( GtkWidget *menu_bar_w, GtkWidget *window_w )
 	}
 	else {
 		/* For spawned cameras */
-		menu_item_w = add_menu_item( menu_w, STR_MNU_Close, NULL, GTK_OBJECT(window_w) );
-		gtk_signal_connect_object( GTK_OBJECT(menu_item_w), "activate",
-		                           GTK_SIGNAL_FUNC(menu_Camera_Close), GTK_OBJECT(window_w) );
+		menu_item_w = add_menu_item( menu_w, STR_MNU_Close, NULL, G_OBJECT(window_w) );
+		g_signal_connect( G_OBJECT(menu_item_w), "activate",
+		                           G_CALLBACK(menu_Camera_Close), G_OBJECT(window_w) );
 		keybind( menu_item_w, "^X" );
 	}
 }
diff --git a/src/menu_cbs.c b/src/menu_cbs.c
index 4db192f..9db78ea 100644
--- a/src/menu_cbs.c
+++ b/src/menu_cbs.c
@@ -116,7 +116,7 @@ velocity_input( GtkWidget *widget, const int *message )
 		init_str = velocity_string( velocity, FALSE );
 		velocity_entry_w = add_entry( widget, init_str, velocity_input, MESG_(VALUE_COMMITTED) );
 		set_entry_width( velocity_entry_w, "000,000,000,000" );
-		gtk_signal_connect( GTK_OBJECT(velocity_entry_w), "changed", GTK_SIGNAL_FUNC(velocity_input), MESG_(VALUE_CHANGED) );
+		g_signal_connect( G_OBJECT(velocity_entry_w), "changed", G_CALLBACK(velocity_input), MESG_(VALUE_CHANGED) );
 		keybind( velocity_entry_w, "^V" );
 		vbox_w = add_vbox( widget, FALSE, 3 );
 		button_w = add_button( vbox_w, NULL, velocity_input, MESG_(UNITS_CHANGED) );
@@ -138,7 +138,7 @@ velocity_input( GtkWidget *widget, const int *message )
 void
 velocity_slider( GtkWidget *widget, const int *message )
 {
-	static GtkObject *velocity_adj;
+	static GtkAdjustment *velocity_adj;
 	static GtkWidget *velocity_vscale_w;
 	static int blocking_changed = FALSE;
 	GtkWidget *frame_w;
@@ -149,7 +149,7 @@ velocity_slider( GtkWidget *widget, const int *message )
 	case VALUE_CHANGED:
 		if (blocking_changed)
 			return;
-		adj_value = GTK_ADJUSTMENT(velocity_adj)->value;
+		adj_value = gtk_adjustment_get_value( GTK_ADJUSTMENT(velocity_adj) );
 		input_val = C * (1.0 - adj_value / 65536.0);
 		/* Halt any ongoing velocity transition */
 		break_transition( &velocity );
@@ -163,7 +163,7 @@ velocity_slider( GtkWidget *widget, const int *message )
 		/* Update slider if its value isn't up-to-date */
 		blocking_changed = TRUE;
 		adj_value = rint( 65536.0 * (1.0 - velocity / C) );
-		if (GTK_ADJUSTMENT(velocity_adj)->value != adj_value)
+		if (gtk_adjustment_get_value( GTK_ADJUSTMENT(velocity_adj) ) != adj_value)
 			gtk_adjustment_set_value( GTK_ADJUSTMENT(velocity_adj), adj_value );
 		blocking_changed = FALSE;
 		return;
@@ -173,8 +173,8 @@ velocity_slider( GtkWidget *widget, const int *message )
 		frame_w = add_frame( widget, NULL );
 		/* Velocity adjustment and scale widget */
 		velocity_adj = gtk_adjustment_new( 65536.0, 0.0, 65536.0, 1.0, 2048.0, 0.0 );
-		gtk_signal_connect( GTK_OBJECT(velocity_adj), "value_changed", GTK_SIGNAL_FUNC(velocity_slider), MESG_(VALUE_CHANGED) );
-		velocity_vscale_w = gtk_vscale_new( GTK_ADJUSTMENT(velocity_adj) );
+		g_signal_connect( G_OBJECT(velocity_adj), "value_changed", G_CALLBACK(velocity_slider), MESG_(VALUE_CHANGED) );
+		velocity_vscale_w = gtk_scale_new( GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT(velocity_adj) );
 		gtk_scale_set_draw_value( GTK_SCALE(velocity_vscale_w), FALSE );
 		/* gtk_box_pack_start( GTK_BOX(hbox_w), velocity_scale_w, FALSE, FALSE, 0 ); */
 		gtk_container_add( GTK_CONTAINER(frame_w), velocity_vscale_w );
@@ -197,8 +197,8 @@ dialog_File_NewLattice( GtkWidget *widget, const int *message )
 {
 	static int active = FALSE;
 	static GtkWidget *dialog_window_w;
-	static GtkObject *size_x_adj, *size_y_adj, *size_z_adj;
-	static GtkObject *smoothness_adj;
+	static GtkAdjustment *size_x_adj, *size_y_adj, *size_z_adj;
+	static GtkAdjustment *smoothness_adj;
 	static int prev_smoothness = DEF_LATTICE_SMOOTH;
 	static float dummy;
 	GtkWidget *main_vbox_w;
@@ -219,11 +219,11 @@ dialog_File_NewLattice( GtkWidget *widget, const int *message )
 	case DIALOG_OK:
 		gtk_widget_hide( dialog_window_w );
 /* TODO: Find out why window widget doesn't actually hide until too late */
-		input_size_x = (int)(GTK_ADJUSTMENT(size_x_adj)->value);
-		input_size_y = (int)(GTK_ADJUSTMENT(size_y_adj)->value);
-		input_size_z = (int)(GTK_ADJUSTMENT(size_z_adj)->value);
+		input_size_x = (int)(gtk_adjustment_get_value( GTK_ADJUSTMENT(size_x_adj) ));
+		input_size_y = (int)(gtk_adjustment_get_value( GTK_ADJUSTMENT(size_y_adj) ));
+		input_size_z = (int)(gtk_adjustment_get_value( GTK_ADJUSTMENT(size_z_adj) ));
 		if (advanced_interface)
-			input_smoothness = (int)(GTK_ADJUSTMENT(smoothness_adj)->value);
+			input_smoothness = (int)(gtk_adjustment_get_value( smoothness_adj ));
 		else
 			input_smoothness = prev_smoothness;
 		/* Redraw or blank the viewports first (do redraw(s) if it
@@ -286,19 +286,19 @@ dialog_File_NewLattice( GtkWidget *widget, const int *message )
 	vbox_w = add_vbox( hbox_w, FALSE, 0 );
 	add_label( vbox_w, "X" );
 	size_x_adj = gtk_adjustment_new( (float)lattice_size_x, 1.0, 16.0, 1.0, 1.0, 0.0 );
-	add_spin_button( vbox_w, size_x_adj );
+	add_spin_button( vbox_w, G_OBJECT(size_x_adj) );
 
 	/* Y spinbutton */
 	vbox_w = add_vbox( hbox_w, FALSE, 0 );
 	add_label( vbox_w, "Y" );
 	size_y_adj = gtk_adjustment_new( (float)lattice_size_y, 1.0, 16.0, 1.0, 1.0, 0.0 );
-	add_spin_button( vbox_w, size_y_adj );
+	add_spin_button( vbox_w, G_OBJECT(size_y_adj) );
 
 	/* Z spinbutton */
 	vbox_w = add_vbox( hbox_w, FALSE, 0 );
 	add_label( vbox_w, "Z" );
 	size_z_adj = gtk_adjustment_new( (float)lattice_size_z, 1.0, 16.0, 1.0, 1.0, 0.0 );
-	add_spin_button( vbox_w, size_z_adj );
+	add_spin_button( vbox_w, G_OBJECT(size_z_adj) );
 
 	if (advanced_interface) {
 		/* Smoothness title frame */
@@ -307,7 +307,7 @@ dialog_File_NewLattice( GtkWidget *widget, const int *message )
 
 		/* Smoothness slider */
 		smoothness_adj = gtk_adjustment_new( (float)prev_smoothness, 3.0, 16.0, 1.0, 1.0, 0.0 );
-		add_hscale( hbox_w, smoothness_adj );
+		add_hscale( hbox_w, G_OBJECT(smoothness_adj) );
 	}
 
 	hbox_w = add_hbox( main_vbox_w, TRUE, 0 );
@@ -409,7 +409,12 @@ dialog_File_SaveSnapshot( GtkWidget *widget, const int *message )
 	char *filename;
 	char *input_str;
 	char init_str[256];
+	GtkWidget *parent_window;
+
+	parent_window = gtk_widget_get_toplevel( widget );
 
+	filesel_w = gtk_file_chooser_dialog_new( STR_DLG_Save_Snapshot, GTK_WINDOW(parent_window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL );
+/*
 	switch (*message) {
 	case DIALOG_OPEN:
 		if (active)
@@ -418,14 +423,14 @@ dialog_File_SaveSnapshot( GtkWidget *widget, const int *message )
 		break;
 
 	case DIALOG_OK:
-		/* Grab and save the specified filename */
+		// Grab and save the specified filename 
 		filename = gtk_file_selection_get_filename( GTK_FILE_SELECTION(filesel_w) );
 		xfree( prev_filename );
 		prev_filename = xstrdup( filename );
-		/* Get snapshot dimensions */
+		// Get snapshot dimensions 
 		input_str = read_entry( size_entry_w );
 		width = (int)strtod( input_str, NULL );
-		/* next part (height) */
+		// next part (height) 
 		input_str = strpbrk( input_str, "xX* " );
 		if (input_str != NULL)
 			input_str = strpbrk( input_str, "0123456789" );
@@ -434,7 +439,7 @@ dialog_File_SaveSnapshot( GtkWidget *widget, const int *message )
 		else
 			height = (3 * width) / 4;
 		if ((width < 100) || (height < 75)) {
-			/* Dimensions are too small (or negative??) */
+			// Dimensions are too small (or negative??)
 			width = MAX(100, width);
 			height = MAX(75, height);
 			sprintf( init_str, "%d x %d", width, height );
@@ -454,7 +459,7 @@ dialog_File_SaveSnapshot( GtkWidget *widget, const int *message )
 			save_snapshot( width, height, prev_filename, format );
 			ogl_draw( 0 );
 		}
-		/* no break/return here */
+		// no break/return here 
 
 	case DIALOG_CLOSE:
 		if (!active)
@@ -465,8 +470,8 @@ dialog_File_SaveSnapshot( GtkWidget *widget, const int *message )
 
 	case IMAGE_FORMAT_PNG:
 	case IMAGE_FORMAT_TIFF:
-		/* Note newly selected format and update filename extension
-		 * (the latter only if it matches previously selected format) */
+		// Note newly selected format and update filename extension
+		    // (the latter only if it matches previously selected format)
 		f1 = format - IMAGE_FORMAT - 1;
 		format = *message;
 		f2 = format - IMAGE_FORMAT - 1;
@@ -481,7 +486,7 @@ dialog_File_SaveSnapshot( GtkWidget *widget, const int *message )
 #endif
 		return;
 	}
-
+*/
 #ifdef HAVE_LIBPNG
 	if (format == -1)
 		format = IMAGE_FORMAT_PNG;
@@ -498,36 +503,76 @@ dialog_File_SaveSnapshot( GtkWidget *widget, const int *message )
 		sprintf( init_str, "%s%s", STR_DLG_snapshot_basename, image_format_exts[f] );
 		prev_filename = xstrdup( init_str );
 	}
-	filesel_w = make_filesel_window( STR_DLG_Save_Snapshot, prev_filename, TRUE, dialog_File_SaveSnapshot );
 
-	/* Frame for image parameters */
-	frame_w = add_frame( GTK_FILE_SELECTION(filesel_w)->main_vbox, STR_DLG_snapshot_Parameters );
+	gtk_file_chooser_set_filename( GTK_FILE_CHOOSER(filesel_w), prev_filename );
 
-	/* hbox for image size/format inputs */
+	// filesel_w = make_filesel_window( STR_DLG_Save_Snapshot, prev_filename, TRUE, dialog_File_SaveSnapshot );
+
+	// Frame for image parameters
+	//frame_w = add_frame( GTK_FILE_CHOOSER_DIALOG(filesel_w), STR_DLG_snapshot_Parameters );
+	frame_w = gtk_frame_new(NULL);
+	gtk_file_chooser_set_extra_widget( GTK_FILE_CHOOSER(filesel_w), frame_w );
+	// hbox for image size/format inputs
 	hbox_w = add_hbox( frame_w, FALSE, 10 );
 
-	/* Snapshot size label & entry */
-	vbox_w = gtk_vbox_new( FALSE, 0 );
+	// Snapshot size label & entry
+	vbox_w = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
 	gtk_box_pack_start( GTK_BOX(hbox_w), vbox_w, TRUE, FALSE, 0 );
 	gtk_widget_show( vbox_w );
 	add_label( vbox_w, STR_DLG_snapshot_Size );
 	sprintf( init_str, "%d x %d", width, height );
 	size_entry_w = add_entry( vbox_w, init_str, NULL, NULL );
 
-	/* Image format option menu */
-	vbox_w = gtk_vbox_new( FALSE, 0 );
-	gtk_box_pack_start( GTK_BOX(hbox_w), vbox_w, TRUE, FALSE, 0 );
-	gtk_widget_show( vbox_w );
-	add_label( vbox_w, STR_DLG_snapshot_Format );
+	// Image format option menu
+	/* This should use some builtin stuff like filters */	
+	//vbox_w = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
+	//gtk_box_pack_start( GTK_BOX(hbox_w), vbox_w, TRUE, FALSE, 0 );
+	//gtk_widget_show( vbox_w );
+	//add_label( vbox_w, STR_DLG_snapshot_Format );
 #ifdef HAVE_LIBPNG
-	option_menu_item( "PNG", dialog_File_SaveSnapshot, MESG_(IMAGE_FORMAT_PNG) );
+	//option_menu_item( "PNG", dialog_File_SaveSnapshot, MESG_(IMAGE_FORMAT_PNG) );
 #endif
 #ifdef HAVE_LIBTIFF
-	option_menu_item( "TIFF", dialog_File_SaveSnapshot, MESG_(IMAGE_FORMAT_TIFF) );
+	//option_menu_item( "TIFF", dialog_File_SaveSnapshot, MESG_(IMAGE_FORMAT_TIFF) );
 #endif
-	add_option_menu( vbox_w );
+	//add_option_menu( vbox_w );
 
 	gtk_widget_show( filesel_w );
+	
+	
+	
+	
+	if (gtk_dialog_run (GTK_DIALOG (filesel_w)) == GTK_RESPONSE_ACCEPT)
+  {
+		// Grab and save the specified filename 
+		filename = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER(filesel_w) );
+		xfree( prev_filename );
+		prev_filename = xstrdup( filename );
+		// Get snapshot dimensions 
+		input_str = read_entry( size_entry_w );
+		width = (int)strtod( input_str, NULL );
+		// next part (height) 
+		input_str = strpbrk( input_str, "xX* " );
+		if (input_str != NULL)
+			input_str = strpbrk( input_str, "0123456789" );
+		if (input_str != NULL)
+			height = (int)strtod( input_str, NULL );
+		else
+			height = (3 * width) / 4;
+		if ((width < 100) || (height < 75)) {
+			// Dimensions are too small (or negative??)
+			width = MAX(100, width);
+			height = MAX(75, height);
+			sprintf( init_str, "%d x %d", width, height );
+			set_entry_text( size_entry_w, init_str );
+			return;
+		}
+		//ogl_blank( 0, NULL );
+		save_snapshot( width, height, prev_filename, format );
+		//ogl_draw( 0 );
+  }
+		gtk_widget_destroy( filesel_w );
+
 }
 #endif /* CAN_SAVE_SNAPSHOT */
 
@@ -634,7 +679,7 @@ dialog_File_ExportSRS( GtkWidget *widget, const int *message )
 	hbox_w = add_hbox( frame_w, FALSE, 10 );
 
 	/* Rendering size label & entry */
-	vbox_w = gtk_vbox_new( FALSE, 0 );
+	vbox_w = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
 	gtk_box_pack_start( GTK_BOX(hbox_w), vbox_w, TRUE, FALSE, 0 );
 	gtk_widget_show( vbox_w );
 	add_label( vbox_w, STR_DLG_srs_Size );
@@ -642,7 +687,7 @@ dialog_File_ExportSRS( GtkWidget *widget, const int *message )
 	size_entry_w = add_entry( vbox_w, init_str, NULL, NULL );
 
 	/* Misc. parameter check buttons */
-	vbox_w = gtk_vbox_new( FALSE, 0 );
+	vbox_w = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
 	gtk_box_pack_start( GTK_BOX(hbox_w), vbox_w, TRUE, FALSE, 0 );
 	gtk_widget_show( vbox_w );
 	stereo_chkbtn_w = add_check_button( vbox_w, STR_DLG_srs_Stereo_view, stereo_view, NULL, NULL );
@@ -660,7 +705,7 @@ menu_Objects_toggles( GtkWidget *widget, const int *message )
 {
 	int flag;
 
-	flag = GTK_CHECK_MENU_ITEM(widget)->active;
+	flag = gtk_check_menu_item_get_active( GTK_CHECK_MENU_ITEM(widget) );
 	auxiliary_objects( *message, flag );
 }
 
@@ -673,7 +718,7 @@ dialog_Objects_Animation( GtkWidget *widget, const int *message )
 	static GtkWidget *x0_entry_w;
 	static GtkWidget *x1_entry_w;
 	static GtkWidget *action_label_w;
-	static GtkObject *loop_time_adj;
+	static GtkAdjustment *loop_time_adj;
 	static float prev_recomm_x0 = 999.0;
 	static float prev_recomm_x1 = -999.0;
 	static float prev_x0;
@@ -723,7 +768,7 @@ dialog_Objects_Animation( GtkWidget *widget, const int *message )
 				input_x0 = prev_x0;
 				input_x1 = prev_x1;
 			}
-			input_loop_time = GTK_ADJUSTMENT(loop_time_adj)->value;
+			input_loop_time = gtk_adjustment_get_value( loop_time_adj );
 			if (input_x0 > input_x1)
 				return;
 			if ((input_x1 - input_x0) < 0.5)
@@ -793,14 +838,14 @@ dialog_Objects_Animation( GtkWidget *widget, const int *message )
 		hbox_w = add_hbox( frame_w, FALSE, 10 );
 	}
 
-	hbox2_w = gtk_hbox_new( FALSE, 0 );
+	hbox2_w = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 );
 	gtk_box_pack_start( GTK_BOX(hbox_w), hbox2_w, TRUE, FALSE, 0 );
 	gtk_widget_show( hbox2_w );
 
 	/* Loop time spin button */
 	add_label( hbox2_w, STR_DLG_Loop_time );
 	loop_time_adj = gtk_adjustment_new( prev_loop_time, 1, 60, 1, 1, 0.0 );
-	add_spin_button( hbox2_w, loop_time_adj );
+	add_spin_button( hbox2_w, G_OBJECT(loop_time_adj) );
 	add_label( hbox2_w, STR_DLG_seconds );
 
 	/* Begin/Stop and Close buttons */
@@ -818,7 +863,7 @@ dialog_Objects_Animation( GtkWidget *widget, const int *message )
 void
 menu_Warp_toggles( GtkWidget *widget, const int *message )
 {
-	if (GTK_CHECK_MENU_ITEM(widget)->active)
+	if (gtk_check_menu_item_get_active( GTK_CHECK_MENU_ITEM(widget) ))
 		warp( *message, MESG_(1) );
 	else
 		warp( *message, MESG_(0) );
@@ -832,7 +877,7 @@ menu_Camera_Lens_select( GtkWidget *widget, const float *new_lens_length )
 	float new_fov;
 
 	new_fov = camera_calc_fov( *new_lens_length );
-	if (GTK_CHECK_MENU_ITEM(widget)->active)
+	if (gtk_check_menu_item_get_active( GTK_CHECK_MENU_ITEM(widget) ))
 		transition( &usr_cams[cur_cam]->fov, FALSE, TRANS_QTR_SIN, 3.0, new_fov, cur_cam );
 }
 
@@ -859,7 +904,7 @@ dialog_Camera_Lens_Custom( GtkWidget *widget, const int *message )
 
 	switch (*message) {
 	case DIALOG_OPEN:
-		if (active || !GTK_CHECK_MENU_ITEM(widget)->active)
+		if (active || !gtk_check_menu_item_get_active( GTK_CHECK_MENU_ITEM(widget) ))
 			return;
 		active = TRUE;
 		break;
@@ -1174,22 +1219,22 @@ dialog_Camera_Position( GtkWidget *widget, const int *message )
 	add_label( vbox_w, "X" );
 	loc_x_entry_w = add_entry( vbox_w, "---", NULL, NULL );
 	set_entry_width( loc_x_entry_w, xyz_span_str );
-	gtk_signal_connect( GTK_OBJECT(loc_x_entry_w), "changed",
-	                    GTK_SIGNAL_FUNC(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
+	g_signal_connect( G_OBJECT(loc_x_entry_w), "changed",
+	                    G_CALLBACK(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
 
 	vbox_w = add_vbox( hbox_w, FALSE, 0 );
 	add_label( vbox_w, "Y" );
 	loc_y_entry_w = add_entry( vbox_w, "---", NULL, NULL );
 	set_entry_width( loc_y_entry_w, xyz_span_str );
-	gtk_signal_connect( GTK_OBJECT(loc_y_entry_w), "changed",
-	                    GTK_SIGNAL_FUNC(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
+	g_signal_connect( G_OBJECT(loc_y_entry_w), "changed",
+	                    G_CALLBACK(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
 
 	vbox_w = add_vbox( hbox_w, FALSE, 0 );
 	add_label( vbox_w, "Z" );
 	loc_z_entry_w = add_entry( vbox_w, "---", NULL, NULL );
 	set_entry_width( loc_z_entry_w, xyz_span_str );
-	gtk_signal_connect( GTK_OBJECT(loc_z_entry_w), "changed",
-	                    GTK_SIGNAL_FUNC(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
+	g_signal_connect( G_OBJECT(loc_z_entry_w), "changed",
+	                    G_CALLBACK(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
 
 	/* Title frame for target entries */
 	targ_frame_w = add_frame( main_vbox_w, "---" );
@@ -1203,31 +1248,31 @@ dialog_Camera_Position( GtkWidget *widget, const int *message )
 	/* The XYZ-target/phi+theta-heading entries */
 
 	/* X or phi */
-	vbox2_w = gtk_vbox_new( FALSE, 0 );
+	vbox2_w = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
 	gtk_box_pack_start( GTK_BOX(hbox_w), vbox2_w, TRUE, FALSE, 0 );
 	gtk_widget_show( vbox2_w );
 	targ_1_label_w = add_label( vbox2_w, "---" );
 	targ_1_entry_w = add_entry( vbox2_w, "---", NULL, NULL );
-	gtk_signal_connect( GTK_OBJECT(targ_1_entry_w), "changed",
-	                    GTK_SIGNAL_FUNC(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
+	g_signal_connect( G_OBJECT(targ_1_entry_w), "changed",
+	                    G_CALLBACK(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
 
 	/* Y or theta */
-	vbox2_w = gtk_vbox_new( FALSE, 0 );
+	vbox2_w = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
 	gtk_box_pack_start( GTK_BOX(hbox_w), vbox2_w, TRUE, FALSE, 0 );
 	gtk_widget_show( vbox2_w );
 	targ_2_label_w = add_label( vbox2_w, "---" );
 	targ_2_entry_w = add_entry( vbox2_w, "---", NULL, NULL );
-	gtk_signal_connect( GTK_OBJECT(targ_2_entry_w), "changed",
-	                    GTK_SIGNAL_FUNC(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
+	g_signal_connect( G_OBJECT(targ_2_entry_w), "changed",
+	                    G_CALLBACK(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
 
 	/* Z */
-	targ_z_vbox_w = gtk_vbox_new( FALSE, 0 );
+	targ_z_vbox_w = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
 	gtk_box_pack_start( GTK_BOX(hbox_w), targ_z_vbox_w, TRUE, FALSE, 0 );
 	gtk_widget_show( targ_z_vbox_w );
 	add_label( targ_z_vbox_w, "Z" );
 	targ_z_entry_w = add_entry( targ_z_vbox_w, "---", NULL, NULL );
-	gtk_signal_connect( GTK_OBJECT(targ_z_entry_w), "changed",
-	                    GTK_SIGNAL_FUNC(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
+	g_signal_connect( G_OBJECT(targ_z_entry_w), "changed",
+	                    G_CALLBACK(dialog_Camera_Position), MESG_(VALUE_CHANGED) );
 
 	/* Entry mode button */
 	button_w = add_button( vbox_w, NULL, dialog_Camera_Position, MESG_(UNITS_CHANGED) );
@@ -1261,7 +1306,7 @@ menu_Camera_InfoDisplay_toggles( GtkWidget *widget, const int *message )
 {
 	int flag;
 
-	flag = GTK_CHECK_MENU_ITEM(widget)->active;
+	flag = gtk_check_menu_item_get_active( GTK_CHECK_MENU_ITEM(widget) );
 	info_display( *message, flag );
 }
 
@@ -1272,7 +1317,7 @@ menu_Camera_Background_select( GtkWidget *widget, const int *color_id )
 {
 	float new_r, new_g, new_b;
 
-	if (!GTK_CHECK_MENU_ITEM(widget)->active)
+	if (!gtk_check_menu_item_get_active( GTK_CHECK_MENU_ITEM(widget) ))
 		return;
 
 #ifdef DEBUG
@@ -1298,7 +1343,7 @@ menu_Camera_GraphicsMode_select( GtkWidget *widget, const int *message )
 	int i;
 
 	/* "toggled" signal also catches "toggle off" */
-	if (!GTK_CHECK_MENU_ITEM(widget)->active)
+	if (!gtk_check_menu_item_get_active( GTK_CHECK_MENU_ITEM(widget) ))
 		return;
 
 	for (i = 0; i < num_cams; i++) {
@@ -1342,17 +1387,18 @@ menu_Camera_Spawn( GtkWidget *widget, void *dummy )
 	/* New window widget */
 	cam_window_w = gtk_window_new( GTK_WINDOW_TOPLEVEL );
 	gtk_window_set_title( GTK_WINDOW(cam_window_w), STR_DLG_Camera );
-	gtk_widget_set_usize( cam_window_w, 400, 300 );
+	gtk_widget_set_size_request( cam_window_w, 400, 300 );
 	gtk_container_set_border_width( GTK_CONTAINER(cam_window_w), 0 );
-	gtk_signal_connect( GTK_OBJECT(cam_window_w), "focus_in_event",
-	                    GTK_SIGNAL_FUNC(camera_set_current), NULL );
-	gtk_signal_connect( GTK_OBJECT(cam_window_w), "delete_event",
-	                    GTK_SIGNAL_FUNC(menu_Camera_Close), NULL );
+	g_signal_connect( G_OBJECT(cam_window_w), "focus_in_event",
+	                    G_CALLBACK(camera_set_current), NULL );
+	g_signal_connect( G_OBJECT(cam_window_w), "delete_event",
+	                    G_CALLBACK(menu_Camera_Close), NULL );
 	/* Destroy window before exiting */
-	gtk_quit_add_destroy( 1, GTK_OBJECT(cam_window_w) );
+	/*TODO: This doesn't work in GTK3 */
+	//gtk_quit_add_destroy( 1, G_OBJECT(cam_window_w) );
 
 	/* Main vertical box widget */
-	main_vbox_w = gtk_vbox_new( FALSE, 0 );
+	main_vbox_w = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
 	gtk_container_set_border_width( GTK_CONTAINER(main_vbox_w), 0 );
 	gtk_container_add( GTK_CONTAINER(cam_window_w), main_vbox_w );
 	gtk_widget_show( main_vbox_w );
@@ -1492,11 +1538,12 @@ dialog_Help_About( GtkWidget *widget, int *message )
                              GTK_STOCK_CLOSE
                              );
 
-	main_vbox_w = gtk_vbox_new(TRUE, 0);
+	main_vbox_w = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0);
 	text_label = gtk_label_new(NULL);
 
 	/* Get the Light Speed! title up */
-	add_pixmap( main_vbox_w, about_window_w, lightspeed_title_xpm );
+	/* Requires many changes to work in GTK3 */
+	// add_pixmap( main_vbox_w, about_window_w, lightspeed_title_xpm );
 
 	sprintf( info_str, STR_DLG_Version_x_y_ARG, VERSION );
 	gtk_label_set_markup(GTK_LABEL(text_label), info_str);
diff --git a/src/misc.c b/src/misc.c
index 807c71f..d971a35 100644
--- a/src/misc.c
+++ b/src/misc.c
@@ -179,13 +179,18 @@ read_system_clock( void )
 void
 set_cursor_glyph( int glyph )
 {
+	static GdkDisplay *display;
+	static GdkWindow * gdk_window;
 	static GdkCursor *cursor;
 	static int prev_glyph = -1;
 
+	display = gdk_display_get_default();
+	gdk_window = gtk_widget_get_window ( usr_cams[cur_cam]->ogl_w );
+
 	if (prev_glyph != -1)
-		gdk_cursor_destroy( cursor );
-	cursor = gdk_cursor_new( glyph );
-	gdk_window_set_cursor( usr_cams[cur_cam]->ogl_w->window, cursor );
+		g_object_unref( cursor );
+	cursor = gdk_cursor_new_for_display( display, glyph );
+	gdk_window_set_cursor( gdk_window, cursor );
 	prev_glyph = glyph;
 }
 
@@ -443,5 +448,6 @@ ss( void )
 	glHint( GL_POLYGON_SMOOTH_HINT, GL_DONT_CARE );
 	glEnable( GL_LIGHTING );
 	glEnable( GL_DEPTH_TEST );
-	gtk_gl_area_swap_buffers( GTK_GL_AREA(cam->ogl_w) );
+	/*TODO: Disable this for GTK3 temporarily */
+	//gtk_gl_area_swap_buffers( GTK_GL_AREA(cam->ogl_w) );
 }
diff --git a/src/ogl.c b/src/ogl.c
index 470d339..2ef6d21 100644
--- a/src/ogl.c
+++ b/src/ogl.c
@@ -70,7 +70,7 @@ ogl_initialize( GtkWidget *ogl_w, void *nothing )
 	/* Initialize ogl_draw_string for primary viewport and pixmap buffers
 	 * (other viewports will get this via shared context) */
 	if ((assoc_cam_id( ogl_w ) == 0) || !on_screen)
-		ogl_draw_string( NULL, INITIALIZE, NIL );
+		/*TODO: Disable for now in GTK3*/ //ogl_draw_string( NULL, INITIALIZE, NIL );
 
 	if (on_screen) {
 		/* Call ogl_resize( ) to finish viewport initialization */
@@ -96,9 +96,13 @@ ogl_resize( GtkWidget *ogl_w, GdkEventConfigure *ev_config, void *nothing )
 	static float dummy;
 	int width, height;
 	int i;
+	GtkAllocation* allocation;
 
-	width = ogl_w->allocation.width;
-	height = ogl_w->allocation.height;
+	allocation = g_new(GtkAllocation, 1);
+	gtk_widget_get_allocation( ogl_w, allocation );
+
+	width = allocation->width;
+	height = allocation->height;
 	gtk_gl_area_make_current( GTK_GL_AREA(ogl_w) );
 	glViewport( 0, 0, width, height );
 
@@ -280,7 +284,7 @@ ogl_draw( int cam_id )
 #endif /* 0 */
 
 	/* Initialize string drawer (i.e. inform of viewport dimensions) */
-	ogl_draw_string( cam, RESET, NIL );
+	/*TODO: Disable for now in GTK3*/ //ogl_draw_string( cam, RESET, NIL );
 
 	/* Finally, draw info display (nothing if it's turned off)
 	 * Only the primary camera or an off-screen image gets this */
@@ -288,7 +292,7 @@ ogl_draw( int cam_id )
 		info_display( INFODISP_DRAW, NIL );
 
 	if (drawing_to_screen) {
-		gtk_gl_area_swap_buffers( GTK_GL_AREA(cam->ogl_w) );
+		/*TODO: Disable for now in GTK3*/ //gtk_gl_area_swap_buffers( GTK_GL_AREA(cam->ogl_w) );
 		profile( PROFILE_OGLDRAW_DONE );
 		cam->redraw = FALSE;
 	}
@@ -306,6 +310,8 @@ ogl_draw( int cam_id )
  * NOTE: This function requires some pre-existing state; namely, the target
  * GL context must already be made current as well as properly initialized
  * (see ogl_blank( ) or info_display( ) to see what I mean) */
+ /* TODO: Deactivate this for now as in GTK3 font handling is completely different */
+ /*
 void
 ogl_draw_string( const void *data, int message, int size )
 {
@@ -329,7 +335,7 @@ ogl_draw_string( const void *data, int message, int size )
 
 	switch (message) {
 	case INITIALIZE:
-		/* First-time initialization */
+		// First-time initialization
 		fonts = xmalloc( num_font_sizes * sizeof(GdkFont *) );
 		font_dlist_bases = xmalloc( num_font_sizes * sizeof(unsigned int *) );
 		font_heights = xmalloc( num_font_sizes * sizeof(int *) );
@@ -348,21 +354,21 @@ ogl_draw_string( const void *data, int message, int size )
 		return;
 
 	case RESET:
-		/* Once-per-GL-redraw initialization */
+		// Once-per-GL-redraw initialization
 		cam = (camera *)data;
-		/* Get GL widget dimensions */
+		// Get GL widget dimensions
 		width = cam->width;
 		height = cam->height;
-		/* Reset line counters */
+		// Reset line counters
 		num_tl_lines = 0;
 		num_tr_lines = 0;
 		num_bl_lines = 0;
 		num_br_lines = 0;
 		num_cen_lines = 0;
-		/* Determine upper limit on the font sizes we should use */
+		// Determine upper limit on the font sizes we should use
 		for (i = 0; i < num_font_sizes; i++) {
-			fn_big = i; /* font number of "big" (size 2) font */
-			/* Test string should be minimally 1/3 viewport width */
+			fn_big = i; // font number of "big" (size 2) font
+			// Test string should be minimally 1/3 viewport width
 			if (gdk_string_width( fonts[i], test_str ) > (width / 3))
 				break;
 		}
@@ -374,7 +380,7 @@ ogl_draw_string( const void *data, int message, int size )
 		break;
 	}
 
-	/* Check string for newlines, and queue if necessary */
+	// Check string for newlines, and queue if necessary
 	i = strcspn( disp_str, "\n" );
 	if (i < strlen( disp_str )) {
 		strcpy( str_buf, disp_str );
@@ -385,10 +391,10 @@ ogl_draw_string( const void *data, int message, int size )
 	else
 		next_disp_str = NULL;
 
-	/* Determine which (proportional) font size to use */
-	fn = MIN(fn_big, MAX(0, fn_big - 2 + size)); /* 0 <= fn <= fn_big */
+	// Determine which (proportional) font size to use
+	fn = MIN(fn_big, MAX(0, fn_big - 2 + size)); // 0 <= fn <= fn_big
 
-	/* x coord. of base point */
+	// x coord. of base point
 	switch (pos_code) {
 	case POS_TOP_LEFT:
 	case POS_BOTTOM_LEFT:
@@ -416,7 +422,7 @@ ogl_draw_string( const void *data, int message, int size )
 		return;
 	}
 
-	/* y coord. of base point */
+	// y coord. of base point
 	switch (pos_code) {
 	case POS_BOTTOM_LEFT:
 	case POS_BOTTOM_RIGHT:
@@ -438,7 +444,7 @@ ogl_draw_string( const void *data, int message, int size )
 		break;
 	}
 
-	/* This makes multi-line readouts possible */
+	// This makes multi-line readouts possible
 	switch (pos_code) {
 	case POS_TOP_LEFT:
 		y -= num_tl_lines * font_heights[fn];
@@ -472,22 +478,22 @@ ogl_draw_string( const void *data, int message, int size )
 	glMatrixMode( GL_MODELVIEW );
 	glLoadIdentity( );
 
-	/* Draw text backing */
+	// Draw text backing
 	glColor3f( INFODISP_TEXT_BACK_R, INFODISP_TEXT_BACK_G, INFODISP_TEXT_BACK_B );
 	glRasterPos2i( x + edge_dx, y + edge_dy );
 	glListBase( font_dlist_bases[fn] );
 	glCallLists( strlen(disp_str), GL_UNSIGNED_BYTE, disp_str );
 
-	/* Draw text face */
+	// Draw text face
 	glColor3f( INFODISP_TEXT_FRONT_R, INFODISP_TEXT_FRONT_G, INFODISP_TEXT_FRONT_B );
 	glRasterPos2i( x, y );
 	glCallLists( strlen(disp_str), GL_UNSIGNED_BYTE, disp_str );
 
-	/* Finally, do next line if disp_str had newlines */
+	// Finally, do next line if disp_str had newlines
 	if (next_disp_str != NULL)
 		ogl_draw_string( next_disp_str, pos_code, size );
 }
-
+*/
 
 /* Blanks out a viewport, optionally displaying a [centered] message */
 void
@@ -503,19 +509,19 @@ ogl_blank( int cam_id, const char *blank_message )
 	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
 	if (blank_message != NULL) {
-		/* Tell ogl_draw_string( ) about GL widget dimensions */
-		ogl_draw_string( cam, RESET, NIL );
+		/* Tell /*TODO: Disable for now in GTK3*/ //ogl_draw_string( ) about GL widget dimensions */
+		/*TODO: Disable for now in GTK3*/ //ogl_draw_string( cam, RESET, NIL );
 
 		glDisable( GL_DEPTH_TEST );
 		glDisable( GL_LIGHTING );
 
-		ogl_draw_string( blank_message, POS_CENTER, 2 );
+		/*TODO: Disable for now in GTK3*/ //ogl_draw_string( blank_message, POS_CENTER, 2 );
 
 		glEnable( GL_LIGHTING );
 		glEnable( GL_DEPTH_TEST );
 	}
 
-	gtk_gl_area_swap_buffers( GTK_GL_AREA(cam->ogl_w) );
+	/*TODO: Disable for now in GTK3*/ //gtk_gl_area_swap_buffers( GTK_GL_AREA(cam->ogl_w) );
 }
 
 
@@ -527,21 +533,18 @@ GtkWidget *
 ogl_make_widget( void )
 {
 	GtkWidget *primary_ogl_w;
-	int gl_area_attributes[] = {
-	    GDK_GL_RGBA,
-	    GDK_GL_RED_SIZE, 1,
-	    GDK_GL_GREEN_SIZE, 1,
-	    GDK_GL_BLUE_SIZE, 1,
-	    GDK_GL_DEPTH_SIZE, 1,
-	    GDK_GL_DOUBLEBUFFER,
-	    GDK_GL_NONE
-	};
 
 	primary_ogl_w = usr_cams[0]->ogl_w;
+	
+	/*
+	// TODO: There is no gtk_gl_area_share_new() in GTK3...
 	if (primary_ogl_w == NULL)
-		return gtk_gl_area_new( gl_area_attributes );
+		return gtk_gl_area_new( );
 	else
-		return gtk_gl_area_share_new( gl_area_attributes, GTK_GL_AREA(primary_ogl_w) );
+		return gtk_gl_area_share_new( GTK_GL_AREA(primary_ogl_w) );
+		
+	*/
+	return gtk_gl_area_new( );
 }
 
 /* end ogl.c */
diff --git a/src/snapshot.c b/src/snapshot.c
index 246433f..1e6d362 100644
--- a/src/snapshot.c
+++ b/src/snapshot.c
@@ -40,7 +40,8 @@ static int write_tiff( int message, const void *data );
 /* [Other] forward declarations */
 static int write_image( int format, int message, const void *data );
 
-
+/*TODO: Deactivate this for now as in GTK3 font handling is completely different */
+/*
 int
 save_snapshot( int width, int height, const char *filename, int format )
 {
@@ -64,12 +65,12 @@ save_snapshot( int width, int height, const char *filename, int format )
 	char comments[1024];
 	char one_line[256];
 
-	/* Initialize output camera */
+	// Initialize output camera
 	memcpy( &out_cam, usr_cams[0], sizeof(camera) );
 	out_cam.width = width;
 	out_cam.height = height;
 
-	/* Create off-screen rendering buffer (i.e. pixmap) */
+	// Create off-screen rendering buffer (i.e. pixmap)
 	visual = gdk_gl_choose_visual( visual_attributes );
 	if (visual == NULL) {
 		message_window( STR_DLG_Error, STR_MSG_no_ogl_visual );
@@ -86,7 +87,7 @@ save_snapshot( int width, int height, const char *filename, int format )
 	err = !gdk_gl_pixmap_make_current( glpixmap, context );
 	if (err) {
 		message_window( STR_DLG_Error, STR_MSG_no_ogl_context );
-		/*TODO: Had to use g_object_unref instead of gdk_gl_context_unref and gdk_gl_pixmap_unref to make compilation possible */
+		//TODO: Had to use g_object_unref instead of gdk_gl_context_unref and gdk_gl_pixmap_unref to make compilation possible
 		g_object_unref( context );
 		g_object_unref( glpixmap );
 		// gdk_gl_context_unref( context );
@@ -95,18 +96,18 @@ save_snapshot( int width, int height, const char *filename, int format )
 		return -1;
 	}
 
-	/* Basic setup */
+	// Basic setup
 	ogl_initialize( NULL, NULL );
 
-	/* For extra-high quality output */
+	// For extra-high quality output
 	glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
 	glHint( GL_POINT_SMOOTH_HINT, GL_NICEST );
 	glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
 	glHint( GL_POLYGON_SMOOTH_HINT, GL_NICEST );
-	/* GL_LINE_SMOOTH looks crummy */
-	/* glEnable( GL_LINE_SMOOTH ); */
+	// GL_LINE_SMOOTH looks crummy
+	// glEnable( GL_LINE_SMOOTH );
 
-	/* Produce image description (comments) */
+	// Produce image description (comments)
 	if (object_mode == MODE_LATTICE) {
 		sprintf( comments, "%dx%dx%d lattice, travelling at %s",
 		         lattice_size_x, lattice_size_y, lattice_size_z,
@@ -141,10 +142,10 @@ save_snapshot( int width, int height, const char *filename, int format )
 	strcat( comments, one_line );
 	sprintf( one_line, "This image was produced by the Light Speed! relativistic simulator.\n" );
 	strcat( comments, one_line );
-/* TODO: Fix description...? it's inaccurate if an animation is ongoing, or
- * if any of the relativistic transforms are switched off */
+// TODO: Fix description...? it's inaccurate if an animation is ongoing, or
+// if any of the relativistic transforms are switched off
 
-	/* Initialize output file */
+	// Initialize output file
 	err = FALSE;
 	err = err || write_image( format, IMAGE_WIDTH, &width );
 	err = err || write_image( format, IMAGE_HEIGHT, &height );
@@ -156,12 +157,12 @@ save_snapshot( int width, int height, const char *filename, int format )
 	}
 
 	ogl_blank( 0, STR_MSG_Rendering_snapshot );
-	gdk_gl_pixmap_make_current( glpixmap, context ); /* switch back */
+	gdk_gl_pixmap_make_current( glpixmap, context ); // switch back
 
-	/* Draw! */
+	// Draw!
 	ogl_draw( -1 );
 
-	/* Read and export rows of pixels, one by one */
+	// Read and export rows of pixels, one by one
 	scanline = xmalloc( width * 3 * sizeof(GLubyte) );
 	glPixelStorei( GL_PACK_ALIGNMENT, 4 );
 	for (ogl_y = height - 1; ogl_y >= 0; ogl_y--) {
@@ -173,17 +174,17 @@ save_snapshot( int width, int height, const char *filename, int format )
 		if (percent != prev_percent) {
 			sprintf( one_line, STR_MSG_Saving_snapshot_ARG, percent );
 			ogl_blank( 0, one_line );
-			/* switch back to pixmap GL context */
+			// switch back to pixmap GL context
 			gdk_gl_pixmap_make_current( glpixmap, context );
 			prev_percent = percent;
 		}
 	}
 	xfree( scanline );
 
-	/* Close up output file */
+	// Close up output file
 	write_image( format, IMAGE_COMPLETE, NULL );
 
-	/*TODO: Had to use g_object_unref instead of gdk_gl_context_unref and gdk_gl_pixmap_unref to make compilation possible */
+	//TODO: Had to use g_object_unref instead of gdk_gl_context_unref and gdk_gl_pixmap_unref to make compilation possible
 	g_object_unref( context );
 	g_object_unref( glpixmap );
 	// gdk_gl_context_unref( context );
@@ -192,7 +193,7 @@ save_snapshot( int width, int height, const char *filename, int format )
 
 	return err;
 }
-
+*/
 
 /* Dispatcher for the various file format handlers */
 static int