Als Service bietet www.stadt-graz.at einen Graz Stadtplan zur besseren Übersicht und Orientierung. Mit den typischen Google Maps Bedienelementen kann in die Graz Karte beispielsweise hinein- und hinausgezoomt werden. Über das Suchfeld kann nach Adressen in Graz gesucht werden!
{"map_options":{"center_lat":"47.074204819721395","center_lng":"15.44017469880796","zoom":5,"map_type_id":"ROADMAP","center_by_nearest":false,"fit_bounds":false,"center_circle_fillcolor":"#8CAEF2","center_circle_strokecolor":"#8CAEF2","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","draggable":true,"scroll_wheel":"false","gesture":"auto","marker_default_icon":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","infowindow_setting":"<div class=\"fc-main\">\n<div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}<\/span><\/div>\n<div class=\"fc-item-featured_image\">{marker_image} <\/div>\n<p>{marker_message}<\/p>\n<address><b>Address : <\/b>{marker_address}<\/address>\n<\/div>\n","infowindow_geotags_setting":"<div class=\"fc-main\"><div class=\"fc-item-title\">{post_title} <span class=\"fc-badge info\">{post_categories}<\/span><\/div> <div class=\"fc-item-featured_image\">{post_featured_image} <\/div>{post_excerpt}<address><b>Address : <\/b>{marker_address}<\/address><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-red\" href=\"{post_link}\">Read More...<\/a><\/div>","infowindow_skin":{"name":"default","type":"infowindow","sourcecode":"&lt;div class=&quot;fc-main&quot;&gt;&lt;div class=&quot;fc-item-title&quot;&gt;{marker_title} &lt;span class=&quot;fc-badge info&quot;&gt;{marker_category}&lt;\/span&gt;&lt;\/div&gt; &lt;div class=&quot;fc-item-featured_image&quot;&gt;{marker_image} &lt;\/div&gt;{marker_message}&lt;address&gt;&lt;b&gt;Address : &lt;\/b&gt;{marker_address}&lt;\/address&gt;&lt;\/div&gt;"},"infowindow_post_skin":{"name":"default","type":"post","sourcecode":"&lt;div class=&quot;fc-main&quot;&gt;&lt;div class=&quot;fc-item-title&quot;&gt;{post_title} &lt;span class=&quot;fc-badge info&quot;&gt;{post_categories}&lt;\/span&gt;&lt;\/div&gt; &lt;div class=&quot;fc-item-featured_image&quot;&gt;{post_featured_image} &lt;\/div&gt;{post_excerpt}&lt;address&gt;&lt;b&gt;Address : &lt;\/b&gt;{marker_address}&lt;\/address&gt;&lt;a target=&quot;_blank&quot; class=&quot;fc-btn fc-btn-small fc-btn-red&quot; href=&quot;{post_link}&quot;&gt;Read More...&lt;\/a&gt;&lt;\/div&gt;"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"default_infowindow_open":false,"infowindow_open_event":"click","is_mobile":false,"infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":false,"full_screen_control":true,"search_control":true,"zoom_control":true,"map_type_control":true,"street_view_control":true,"locateme_control":false,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"12","max_zoom":"19","zoom_level_after_search":"10","url_filters":false,"doubleclickzoom":false,"current_post_only":false,"bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"450"},"places":[{"source":"post","title":"Schlossbergbahn: Fahrt auf den Schlossberg mit Panoramablick auf Graz","infowindow_content":"<div class=\"fc-main\"><div class=\"fc-item-title\">Schlossbergbahn: Fahrt auf den Schlossberg mit Panoramablick auf Graz <span class=\"fc-badge info\">Ausfl\u00fcge in Graz, Sehensw\u00fcrdigkeiten in Graz, Service<\/span><\/div> <div class=\"fc-item-featured_image\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Schlossbergbahn: Fahrt auf den Schlossberg mit Panoramablick auf Graz\" width=\"300\" height=\"199\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossbergbahn-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div> <\/div>Die Grazer Schlossbergbahn bietet einen besonderen Fahrspa\u00df und einen wundersch\u00f6nen Blick auf die Stadt Graz.<address><b>Address : <\/b>{marker_address}<\/address><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-red\" href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossbergbahn.html\">Read More...<\/a><\/div>","content":"Die Grazer Schlossbergbahn bietet einen besonderen Fahrspa\u00df und einen wundersch\u00f6nen Blick auf die Stadt Graz.","address":"Schlossbergbahn, 8010 Graz, \u00d6sterreich","location":{"lat":"47.0754195","city":"Graz","state":"Steiermark","country":"\u00d6sterreich","lng":"15.4357481","onclick_action":"marker","redirect_permalink":"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossbergbahn.html","zoom":5,"extra_fields":{"post_excerpt":"Die Grazer Schlossbergbahn bietet einen besonderen Fahrspa\u00df und einen wundersch\u00f6nen Blick auf die Stadt Graz.","post_content":"Die <strong>Grazer Schlossbergbahn<\/strong> bietet mit ihren gl\u00e4sernen D\u00e4chern ausgestatteten Wagen, einen besonderen Fahrspa\u00df und einen <strong>wundersch\u00f6nen Blick auf die Stadt Graz<\/strong>. Sie ist eine Standseilbahn und bef\u00f6rdert ihre Fahrg\u00e4ste seit 1894 in wenigen Minuten zur Bergstation auf dem <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html\">Grazer Schlossberg<\/a>. Ausgangspunkt vieler Sightseeing-Touren auf dem Schlo\u00dfberg wie beispielsweise zum <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/uhrturm.html\">Uhrturm<\/a>.\r\n\r\n[caption id=\"attachment_2897\" align=\"alignnone\" width=\"696\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2021\/07\/schlossbergbahn-linie.jpg\"><img class=\"size-large wp-image-2897\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2021\/07\/schlossbergbahn-linie-1024x682.jpg\" alt=\"Schlo\u00dfbergbahn LInie\" width=\"696\" height=\"464\" \/><\/a> In einer lang geschwungenen S-Kurve verlaufende Trasse, erklimmt die Bahn mit ihren beiden roten Wagen den Schlossberg vom Kaiser-Franz-Josef-Kai an der Westseite. Auf einer Streckenl\u00e4nge von 212 m, \u00fcberwindet sie dabei einen H\u00f6henunterschied von 108,95 m bei einer Steigung von 60 Prozent. In der Mitte der Strecke befindet sich eine Ausweiche, an der die zwei Wagen aneinander vorbei fahren k\u00f6nnen.[\/caption]\r\n\r\nInformiere dich hier \u00fcber <strong>aktuelle \u00d6ffnungszeiten und Preise<\/strong> und wie alles im 16. Jahrhundert begonnen hat. <em>Schreibe uns deine Erfahrungen mit der Grazer Schlossbergbahn!<\/em>\r\n\r\n[toc]\r\n<h2>Schlossbergbahn \u00d6ffnungszeiten<\/h2>\r\nDie Wagen der Schlo\u00dfbergbahn verkehren regelm\u00e4\u00dfig alle 15 Minuten (zu jeder vollen Viertelstunde), bei Bedarf auch in k\u00fcrzeren Abst\u00e4nden:\r\n<ul>\r\n \t<li>Montag bis Donnerstag: 10 - 24 Uhr<\/li>\r\n \t<li>Freitag und Samstag: 10 - 02 Uhr<\/li>\r\n \t<li>Sonntag: 10 - 24 Uhr<\/li>\r\n<\/ul>\r\n<h2>Schlossbergbahn Preise<\/h2>\r\n<ul>\r\n \t<li>Alle Tickets der Graz Linien der Zone 1 gelten auch f\u00fcr die Schlossbergbahn!<\/li>\r\n<\/ul>\r\n<div style=\"overflow-x: auto;\">\r\n<table>\r\n<thead>\r\n<tr>\r\n<th>Ticketpreise 2023<\/th>\r\n<th>Stundenkarte<\/th>\r\n<th>24-Stundenkarte<\/th>\r\n<th>Berg- &amp; Talfahrt ab 17 Uhr<\/th>\r\n<th>Kombikarte Schlo\u00dfberg*<\/th>\r\n<\/tr>\r\n<\/thead>\r\n<tbody>\r\n<tr>\r\n<td>Erwachsene<\/td>\r\n<td>\u20ac 2,70<\/td>\r\n<td>\u20ac 5,80<\/td>\r\n<td>\u20ac 5,40<\/td>\r\n<td>\u20ac 4<\/td>\r\n<\/tr>\r\n<tr>\r\n<td>Kinder <em>(<span class=\"subline\">6 bis 14 Jahren)<\/span><\/em><\/td>\r\n<td>\u20ac 1,40<\/td>\r\n<td>\u20ac 2,90<\/td>\r\n<td>\u20ac 2,90<\/td>\r\n<td>\u20ac 2,50<\/td>\r\n<\/tr>\r\n<tr>\r\n<td>Jugendliche<em> (<span class=\"subline\">15 bis 18 Jahren)<\/span><\/em><\/td>\r\n<td>\u20ac 1,70<\/td>\r\n<td>\u20ac 3,60<\/td>\r\n<td>\u20ac 3,40<\/td>\r\n<td>-<\/td>\r\n<\/tr>\r\n<tr>\r\n<td>Eltern &amp; SeniorInnen**<\/td>\r\n<td>\u20ac 1,70<\/td>\r\n<td>\u20ac 3,60<\/td>\r\n<td>\u20ac 3,40<\/td>\r\n<td>\u20ac 2,5<\/td>\r\n<\/tr>\r\n<tr>\r\n<td>Erm\u00e4\u00dfigt <em>(<span class=\"subline\">Menschen mit Behinderung)<\/span><\/em><\/td>\r\n<td>\u20ac 1,40<\/td>\r\n<td>\u20ac 2,90<\/td>\r\n<td>\u20ac 2,90<\/td>\r\n<td>-<\/td>\r\n<\/tr>\r\n<tr>\r\n<td>gr\u00f6\u00dfere <a href=\"https:\/\/www.stadt-graz.at\/blog\/unterwegs-mit-hund.html\">Hunde<\/a><\/td>\r\n<td>\u20ac 1,40<\/td>\r\n<td>\u20ac 2,90<\/td>\r\n<td>\u20ac 2,90<\/td>\r\n<td>-<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/div>\r\n<section class=\"section\">\r\n<div class=\"tables container\">\r\n<div class=\"table__description\"><span class=\"subline\">* 1 Fahrt mit der Schlo\u00dfbergbahn und 1 Fahrt mit dem Schlo\u00dfberglift, keine zeitliche Beschr\u00e4nkung\r\n** f\u00fcr Senior:innen ab dem 60. Lebensjahr in Verbindung mit der \u00d6BB Senior Card. F\u00fcr Eltern im Rahmen der Familienerm\u00e4\u00dfigung\r\n<\/span><\/div>\r\n<\/div>\r\n<\/section>\r\n<h2>Anreise zur Schlossbergbahn<\/h2>\r\n\r\n\r\nDie <strong>Talstation der Bahn<\/strong> erreicht man in der N\u00e4he der <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/grazer-altstadt.html\">Altstadt<\/a> zu Fu\u00df (Kaiser-Franz-Josef-Kai 38, 8010 Graz), mit den <a href=\"https:\/\/www.stadt-graz.at\/service\/strassenbahn-bus-graz.html\">Stra\u00dfenbahnlinien 3 und 5<\/a> (Haltestelle Schlossbergbahn) oder mit dem Auto in der Kurzparkzone entlang der Mur (Lendkai, ...). Hier gilt die <a href=\"https:\/\/www.stadt-graz.at\/service\/parken-in-graz.html\">geb\u00fchrenpflichtige \"Blaue Zone\"<\/a>. Parkscheine erh\u00e4lt man an den Parkscheinautomaten.\r\n\r\nhttps:\/\/youtube.com\/shorts\/KOTFuZG8Uzw?feature=share\r\n\r\nDie <strong>Bergstation<\/strong> befindet sich beim Eingang zu den Kasematten und gleich angrenzend zum Schlo\u00dfberg Restaurant beziehungsweise gegen\u00fcber dem Biergarten. Von hier aus sind es nur wenige Schritte bis zum Liesl Glockenturm.\r\n<h2>Geschichte der Schlossbergbahn: Vom \u201eEselstrieb\u201c zur Panoramabahn<\/h2>\r\nLaut Aufzeichnungen gab es auf dem <strong>Schlossberg schon 1528 eine Bahn<\/strong>, also die \u00e4lteste Seilbahn Mitteleuropas. Dieser Seilzug hatte Steine und Ziegel f\u00fcr den Festungsbau in kleinen Wagen hinaufbef\u00f6rdert, die mithilfe eines Flaschenzugs hochbewegt wurden. Die bewegende Kraft \u00fcbte ein G\u00f6pel aus, der von Eseln oder Pferden im Kreis bewegt wurde. So entstand der Name ,,Eselstrieb\" im Volk.\r\n\r\nUm den Festungsbau zu beschleunigen, wurden 1544 noch zwei weitere Seilbahnen errichtet. Eine direkt neben der ersten, die andere auf der S\u00fcdseite des Schlossberges. Als die Festung 1595 fertiggestellt war, kam es zur Auflassung der beiden Seilbahnen.\r\n<h3>Fast 300 Jahre f\u00fchrte keine Seilbahn auf den Schlossberg<\/h3>\r\nNach sieben Jahren Planungsphase erhielten am 19. M\u00e4rz 1893 den Auftrag zum Bau und Betrieb einer Drahtseilbahn an den Ingenieur Ludwig Schmidt, Carl Fritscher und Georg Ottermann. Ausgangspunkt war das Haus Sackstra\u00dfe 56. Am 19. Oktober 1893 erfolgte der erste Sprengschuss, Ende August 1894 war der Gleisbau abgeschlossen. Am 25. November ging die Schlossbergbahn bei starkem Schneefall in Betrieb.\r\n\r\n<a href=\"https:\/\/www.steirische-spezialitaeten.at\/ausfluege\/peter-rosegger-waldheimat.html\" target=\"_blank\" rel=\"noopener\">Peter Rosegger<\/a> sagte einmal zutreffend:\r\n<blockquote class=\"td_quote_box td_box_center\">Die beiden roten Wagen fahren abwechselnd st\u00fcckerlweise in den Himmel.<\/blockquote>\r\nBis 3. September 1899 wurde die Bahn durch eine feststehende Dampfmaschine angetrieben und am 12. April 1900 erfolgte die Umstellung auf Elektroantrieb. Vom 3. Oktober 1960 bis zum 9. Juni 1961 erfolgte ein Schienenumbau und neue Wagen wurden gekauft.\r\n<h3>Ende der 2. Wagengeneration nach 43 Jahren<\/h3>\r\nWunsch der Grazer Verkehrsbetriebe war die F\u00f6rderleistung zu erh\u00f6hen. Dazu war ein gesamter Umbau der Berg- und Talstation inklusive der beiden neuen Schlo\u00dfbergbahnwagen n\u00f6tig und ergab insgesamt eine Investitionssumme von ca. 2,5 Mio. Euro.\r\n\r\nAm 29. Februar 2004 war es soweit, die zweite Generation der Schlo\u00dfbergbahn hatten nach 43 Betriebsjahren ihren letzten Betriebstag und tausende Grazerinnen und Grazer st\u00fcrmten diese, um noch ein Erinnerungsfoto zu machen. Am 6. M\u00e4rz 2004 wurden die beiden alten Schlo\u00dfbergbahnwagen in einer spektakul\u00e4ren Aktion mit einem Kran \u00fcber die H\u00e4userfront gehoben und in die Remise Steyrergasse gebracht.\r\n\r\nAm 1. August 2004 wurde der Betrieb mit den neuen Panoramawagen im modernen, fahrgastfreundlichen Design wieder aufgenommen. F\u00fcr die ca. 8.000 Fahrg\u00e4ste gab es an diesem Tag Freifahrt. Die zwei modernen neuen Wagen k\u00f6nnen nun je 58 Personen transportieren. Das Design der Wagen wurde von den Grazer Verkehrsbetrieben in Kooperation mit der Fachhochschule f\u00fcr Industrial Design entworfen. Die beiden Wagen haben Glasd\u00e4cher, welche den Fahrg\u00e4sten einen <strong>wunderbaren Panoramablick<\/strong> \u00fcber die D\u00e4cher von Graz bieten.\r\n<h3>2021 \u2013 die Schlo\u00dfbergbahn-Wagen im neuen Design<\/h3>\r\n[caption id=\"attachment_2896\" align=\"alignnone\" width=\"696\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2021\/07\/schlossbergwagen-weisse-lackierung.jpg\"><img class=\"size-large wp-image-2896\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2021\/07\/schlossbergwagen-weisse-lackierung-1024x682.jpg\" alt=\"Schlo\u00dfbergwagen in wei\u00dfer Lackierung\" width=\"696\" height=\"464\" \/><\/a> Schlo\u00dfbergwagen in wei\u00dfer Lackierung. Im Innenraum sind die durchsichtigen Folien mit k\u00fcnstlerischen Aufdrucken zu erkennen.[\/caption]\r\n\r\nDie Schlo\u00dfbergbahn sollte ein Teil des \u201eKulturjahres 2020\u201c in Graz sein, doch auf Grund der COVID-19-Pandemie weitgehend ins Jahr 2021 verlegt. Deswegen ist die Schlo\u00dfbergbahn derzeit nicht im gewohnten roten Design, sondern im k\u00fcnstlerisch gestalteten wei\u00df-schwarzen Design unterwegs.\r\n\r\nIm Rahmen der Installation \u201eSpace*Object*Inbetween\u201c verwandelte sich die Schlo\u00dfbergbahn n\u00e4mlich unter der Leitung des Grazer K\u00fcnstlerduos \u201estudio ASYNCHROME\u201c in eine utopische Zone. Insgesamt ein Jahr dauerten die Vorbereitungen f\u00fcr das K\u00fcnstlerprojekt. Innerhalb einer Woche wurden mit Hilfe einer technisch innovativen Spezialfolie Zeichnungen des Duos auf die Glasfronten der Seilbahnkabinen affichiert, die Strukturen, Netzwerke und Zusammenh\u00e4nge sichtbar und erlebbar machen. Der Ausblick auf die Stadt, also das analoge Panorama, wird so von einem digitalen Panoptikum \u00fcberlagert, das erlaubt, neue Perspektiven und M\u00f6glichkeitsr\u00e4ume zu entdecken und selbst Teil der Zeichnungen zu werden.\r\n\r\nhttps:\/\/youtu.be\/UpVhrcSmo0g\r\n\r\nVom 31. J\u00e4nner bis 19. Juni 2022 wurden <a href=\"https:\/\/www.stadt-graz.at\/videos\/fahrt-mit-der-schlossbergbahn.html\">Sanierungsarbeiten an der Trasse<\/a> durchgef\u00fchrt. 70 Seilrollen, 200 Stufen, 3.000 Schraubverbindungen, 180 m Kabelf\u00fchrung wurden aus- und wieder eingebaut. 3.500 kg Beschichtung wurden heruntergestemmt und geschliffen, 5.000 kg wurden f\u00fcr die neue Beschichtung gebracht, 4.000 kg Quarzsand wurde f\u00fcr die Rutschfestigkeit auf der schr\u00e4gen Trasse eingestreut.\r\n\r\n<strong>Mehr zum Thema<\/strong>\r\n\r\n<a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html\">Alles rund um den Schlo\u00dfberg<\/a>","post_title":"Schlossbergbahn: Fahrt auf den Schlossberg mit Panoramablick auf Graz","post_link":"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossbergbahn.html","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Schlossbergbahn: Fahrt auf den Schlossberg mit Panoramablick auf Graz\" width=\"300\" height=\"199\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossbergbahn-300x199.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Ausfl\u00fcge in Graz, Sehensw\u00fcrdigkeiten in Graz, Service","post_tags":"Aussicht, Schlo\u00dfberg","%_edit_lock%":"1690709715:1","%_edit_last%":"1","%_thumbnail_id%":"281","%_wpgmp_location_address%":"Schlossbergbahn, 8010 Graz, \u00d6sterreich","%_wpgmp_location_city%":"Graz","%_wpgmp_location_state%":"Steiermark","%_wpgmp_location_country%":"\u00d6sterreich","%_wpgmp_metabox_latitude%":"47.0754195","%_wpgmp_metabox_longitude%":"15.4357481","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"3\";i:1;s:1:\"4\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%tdc_dirty_content%":"1","%tdc_icon_fonts%":"","%_yoast_wpseo_focuskw%":"Schlossbergbahn","%_yoast_wpseo_title%":"Schlossbergbahn - Fahrt auf den Schlossberg mit Blick auf Graz","%_yoast_wpseo_metadesc%":"Die Grazer Schlossbergbahn bietet einen besonderen Fahrspa\u00df und wundersch\u00f6nen Blick auf die Stadt Graz \u2713 \u00d6ffnungszeiten \u2713 Preise \u2713 Geschichte","%_yoast_wpseo_linkdex%":"81","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_primary_category%":"2","%ratings_users%":"0","%ratings_score%":"0","%ratings_average%":"0","%post_views_count%":"12312","%td_post_theme_settings%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_eeceb1dfbed111a5eb4d8218c4eae9ea%":"<iframe title=\"Grazer Schlo\u00dfbergbahn: Fahrt mit Panoramablick im Fr\u00fchling\" width=\"696\" height=\"392\" src=\"https:\/\/www.youtube.com\/embed\/UpVhrcSmo0g?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_eeceb1dfbed111a5eb4d8218c4eae9ea%":"1690637729","%_wp_old_date%":"2021-07-29","%_oembed_a6417a93649d29753ff866112d6b99ca%":"<iframe title=\"Schlossbergbahn Fahrt mit herrlichem Blick auf Graz im Fr\u00fchling\" width=\"696\" height=\"392\" src=\"https:\/\/www.youtube.com\/embed\/KOTFuZG8Uzw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_a6417a93649d29753ff866112d6b99ca%":"1690637729","%tdb_template_type%":"","%_oembed_de085fa69256b5aebf091d897209dab4%":"<iframe title=\"Schlossbergbahn Fahrt mit herrlichem Blick auf Graz im Fr\u00fchling\" width=\"1068\" height=\"601\" src=\"https:\/\/www.youtube.com\/embed\/KOTFuZG8Uzw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_de085fa69256b5aebf091d897209dab4%":"1690641228","%_oembed_3e2e95d47a38f1d44de4185463a608e4%":"<iframe title=\"Grazer Schlo\u00dfbergbahn: Fahrt mit Panoramablick im Fr\u00fchling\" width=\"1068\" height=\"601\" src=\"https:\/\/www.youtube.com\/embed\/UpVhrcSmo0g?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_3e2e95d47a38f1d44de4185463a608e4%":"1690641228","taxonomy=category":"Ausfl\u00fcge in Graz, Sehensw\u00fcrdigkeiten in Graz, Service","taxonomy=post_tag":"Aussicht, Schlo\u00dfberg","taxonomy=post_format":""},"icon":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png"},"id":2876,"infowindow_disable":false,"categories":[{"icon":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","name":"Sehensw\u00fcrdigkeiten","id":"2","type":"category"}]},{"source":"post","title":"Waldcaf\u00e9 Thalersee in Thal bei Graz: Essen &#038; Trinken mit Seeblick","infowindow_content":"<div class=\"fc-main\"><div class=\"fc-item-title\">Waldcaf\u00e9 Thalersee in Thal bei Graz: Essen &#038; Trinken mit Seeblick <span class=\"fc-badge info\">Ausfl\u00fcge in Graz, Kulinarik<\/span><\/div> <div class=\"fc-item-featured_image\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Waldcafe Thalersee in Thal bei Graz\" width=\"300\" height=\"200\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2022\/07\/waldcafe-thalersee-thal-bei-graz-2747-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div> <\/div>Im Juli 2022 pr\u00e4sentierte sich erstmals das neue Waldcafe Thalersee. Die tats\u00e4chliche Er\u00f6ffnung soll aber erst Mitte August erfolgen. Als P\u00e4chter wurden die Wiener Gastronomen Manuel K\u00f6pf und Andreas Kn\u00fcnz an Bord geholt. Die geplanten \u00d6ffnungszeiten sind t\u00e4glich von 9 bis 24 Uhr. Die Details zum neu gebauten Restaurant und Cafe am Thalersee: Erreichbarkeit mit [&hellip;]<address><b>Address : <\/b>{marker_address}<\/address><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-red\" href=\"https:\/\/www.stadt-graz.at\/kulinarik\/waldcafe-thalersee.html\">Read More...<\/a><\/div>","content":"Im Juli 2022 pr\u00e4sentierte sich erstmals das neue Waldcafe Thalersee. Die tats\u00e4chliche Er\u00f6ffnung soll aber erst Mitte August erfolgen. Als P\u00e4chter wurden die Wiener Gastronomen Manuel K\u00f6pf und Andreas Kn\u00fcnz an Bord geholt. Die geplanten \u00d6ffnungszeiten sind t\u00e4glich von 9 bis 24 Uhr. Die Details zum neu gebauten Restaurant und Cafe am Thalersee: Erreichbarkeit mit [&hellip;]","address":"Thalerseestra\u00dfe 100, 8051 Thal, \u00d6sterreich","location":{"lat":"47.0717112","city":"Thal","state":"Steiermark","country":"\u00d6sterreich","lng":"15.3653639","onclick_action":"marker","redirect_permalink":"https:\/\/www.stadt-graz.at\/kulinarik\/waldcafe-thalersee.html","zoom":5,"extra_fields":{"post_excerpt":"Im Juli 2022 pr\u00e4sentierte sich erstmals das neue Waldcafe Thalersee. Die tats\u00e4chliche Er\u00f6ffnung soll aber erst Mitte August erfolgen. Als P\u00e4chter wurden die Wiener Gastronomen Manuel K\u00f6pf und Andreas Kn\u00fcnz an Bord geholt. Die geplanten \u00d6ffnungszeiten sind t\u00e4glich von 9 bis 24 Uhr. Die Details zum neu gebauten Restaurant und Cafe am Thalersee: Erreichbarkeit mit [&hellip;]","post_content":"Im Juli 2022 pr\u00e4sentierte sich erstmals das neue <strong>Waldcafe Thalersee<\/strong>. Die tats\u00e4chliche Er\u00f6ffnung soll aber erst Mitte August erfolgen. Als P\u00e4chter wurden die Wiener Gastronomen <strong>Manuel K\u00f6pf<\/strong> und <strong>Andreas Kn\u00fcnz<\/strong> an Bord geholt. Die geplanten \u00d6ffnungszeiten sind t\u00e4glich von 9 bis 24 Uhr.\r\n\r\nDie Details zum neu gebauten Restaurant und Cafe am <a href=\"https:\/\/www.stadt-graz.at\/ausfluege\/thalersee-graz.html\">Thalersee<\/a>:\r\n<ul>\r\n \t<li>Erreichbarkeit mit der Linie 48 von G\u00f6sting<\/li>\r\n \t<li>100 Parkpl\u00e4tze auf dem Gel\u00e4nde<\/li>\r\n \t<li>Ladestationen f\u00fcr E-Bikes und E-Autos sowie Vorbereitungen f\u00fcr einen E-Bus<\/li>\r\n \t<li>100 Sitzpl\u00e4tze drinnen, 100 Sitzpl\u00e4tze drau\u00dfen<\/li>\r\n \t<li>Kein Konsumzwang: Seebesucher:innen k\u00f6nnen eigene Sanit\u00e4ranlagen mit WCs benutzen<\/li>\r\n \t<li>Das Geb\u00e4ude wurde barrierefrei gestaltet<\/li>\r\n<\/ul>\r\nDas Geb\u00e4ude mit seinen gro\u00dfen Stufenterassen wurde von dem Grazer Architektenteam <strong>Pittino &amp; Ortner<\/strong> geplant.\r\n<blockquote class=\"td_quote_box td_box_center\">Der Thalersee ist ein magischer Ort, der mit den Erinnerungen unz\u00e4hliger Besucher:innen in seiner fast 100-j\u00e4hrigen Geschichte verkn\u00fcpft ist, Diese vertr\u00e4umte Welt von damals in neuer Form aufleben zu lassen, war eine Reise in die Geschichte des Thalersees und seines Strandbars, die hier stark eingeflossen ist.<\/blockquote>\r\nso <strong>Gerd Zehetner<\/strong> von <strong>archiguards<\/strong>. Viele der M\u00f6bel und Lampen im Innen- und Au\u00dfenbereich wurden eigens entworfen um die Einzigartigkeit dieses Ortes zu unterstreichen. Dabei nimm die Lichtgestaltung R\u00fccksicht auf den gro\u00dfartigen Naturraum in dem das Geb\u00e4ude eingebettet ist.\r\n\r\nDie <strong>Revitalisierung<\/strong> fand unter Verwendung einer F\u00f6rderung des Klimafonds der Stadt Graz statt. F\u00fcr das umliegende gro\u00dfe Areal sind in den n\u00e4chsten Monaten zahlreiche Veranstaltungen und Freizeitangebote geplant. Im Zuge der Neugestaltung wurde insbesondere auf <strong>\u00f6kologische Bauma\u00dfnahmen<\/strong> geachtet. Konkret geht es hier um die Seewassernutzung f\u00fcr Heiz- und K\u00fchlzwecke, um die Verwendung verbesserter, \u00f6kologischer und nachhaltiger Baustoffe sowie eine speziell energieschonende Gastronomieausstattung.\r\n\r\n[caption id=\"attachment_3214\" align=\"alignnone\" width=\"696\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2022\/07\/waldcafe-thalersee-uebernachten-2769.jpg\"><img class=\"wp-image-3214 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2022\/07\/waldcafe-thalersee-uebernachten-2769-1024x682.jpg\" alt=\"\u00dcbernachten mit Blick auf den See im Waldcafe Thalersee\" width=\"696\" height=\"464\" \/><\/a> Der Balkon der G\u00e4stezimmer im Waldcafe Thalersee mit sch\u00f6nen Ausblick.[\/caption]\r\n<h2>Essen &amp; Trinken am Thalersee<\/h2>\r\nDer Einbezug der Regionalit\u00e4t zieht sich auch durch das <strong>Gastronomie-Konzept<\/strong> von Manuel K\u00f6pf und Andreas K\u00fcnz:\r\n<blockquote class=\"td_quote_box td_box_center\">Wir wollen \u00fcberraschen, uns nicht auf eine K\u00fcche festlegen, sondern Variationen bieten, die viele erreichen. So wird es ein vielseitiges kulinarisches Angebot, von der Deluxe-Version von Schwimmbadpommes im Stanitzel bis hin zu Calamari fritti, geben. Und selbst wenn man bei uns nicht Urlaub macht, ist das Waldcafe Thalersee mit seiner unmittelbaren Erreichbarkeit von Graz aus, der perfekte Platz, um sein Home Office an den See zu verlegen.<\/blockquote>\r\nWer den <a href=\"https:\/\/www.stadt-graz.at\/ausfluege\/thalersee-graz.html\">Thalersee zu Fu\u00df erkunden<\/a> und dabei nicht auf K\u00f6stlichkeiten verzichten m\u00f6chte, hat mit einem vom Waldcafe Thalersee gef\u00fcllten Picknickkorb, die M\u00f6glichkeit dazu.\r\n\r\nhttps:\/\/www.youtube.com\/watch?v=S35Qzwkp650\r\n\r\n<strong>Adresse:<\/strong>\r\n\r\nWaldcafe Thalersee\r\nThalerseestra\u00dfe 100\r\n8051 Thal","post_title":"Waldcaf\u00e9 Thalersee in Thal bei Graz: Essen &#038; Trinken mit Seeblick","post_link":"https:\/\/www.stadt-graz.at\/kulinarik\/waldcafe-thalersee.html","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Waldcafe Thalersee in Thal bei Graz\" width=\"300\" height=\"200\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2022\/07\/waldcafe-thalersee-thal-bei-graz-2747-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Ausfl\u00fcge in Graz, Kulinarik","post_tags":"Essen, See, Trinken","%_edit_lock%":"1660649876:1","%_edit_last%":"1","%_wpgmp_location_address%":"Thalerseestra\u00dfe 100, 8051 Thal, \u00d6sterreich","%_wpgmp_location_city%":"Thal","%_wpgmp_location_state%":"Steiermark","%_wpgmp_location_country%":"\u00d6sterreich","%_wpgmp_metabox_latitude%":"47.0717112","%_wpgmp_metabox_longitude%":"15.3653639","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%tdc_dirty_content%":"1","%tdc_icon_fonts%":"","%td_post_theme_settings%":"135, Die M\u00f6glichkeiten den Thalersee mitsamt seinem Freizeitangebot das Waldcafe zu genie\u00dfen, sind vielf\u00e4tig. Neben den Seeterassen, warten Rad- und Bootsverleih, Salon, Bar, Cafe, sechs G\u00e4stezimmer sowie ein Konferenzraum.","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_category%":"135","%post_views_count%":"13115","%_thumbnail_id%":"3209","%ratings_users%":"0","%ratings_score%":"0","%ratings_average%":"0","%_yoast_wpseo_focuskw%":"Waldcafe Thalersee","%_yoast_wpseo_title%":"%%title%%","%_yoast_wpseo_metadesc%":"Erfahre hier alle wichtigen Infos \u00fcber das neue Restaurant und Cafe am Thalersee. Essen & Trinken mit einem wunderbaren Blick auf den See.","%_yoast_wpseo_linkdex%":"66","%_oembed_63befe98bb50987ab560739b346297da%":"<iframe title=\"Pr\u00e4sentation Waldcaf\u00e9 Thalersee in Thal bei Graz\" width=\"696\" height=\"392\" src=\"https:\/\/www.youtube.com\/embed\/S35Qzwkp650?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_63befe98bb50987ab560739b346297da%":"1660650015","%_oembed_33c8348c299333ef2db273035dd1f00c%":"<iframe title=\"Pr\u00e4sentation Waldcaf\u00e9 Thalersee in Thal bei Graz\" width=\"1068\" height=\"601\" src=\"https:\/\/www.youtube.com\/embed\/S35Qzwkp650?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_33c8348c299333ef2db273035dd1f00c%":"1690641228","taxonomy=category":"Ausfl\u00fcge in Graz, Kulinarik","taxonomy=post_tag":"Essen, See, Trinken","taxonomy=post_format":""},"icon":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png"},"id":3206,"infowindow_disable":false},{"source":"post","title":"Landeszeughaus: R\u00fcstungen &#038; Waffen in historischer Umgebung","infowindow_content":"<div class=\"fc-main\"><div class=\"fc-item-title\">Landeszeughaus: R\u00fcstungen &#038; Waffen in historischer Umgebung <span class=\"fc-badge info\">Museen &amp; Ausstellungen, Sehensw\u00fcrdigkeiten in Graz<\/span><\/div> <div class=\"fc-item-featured_image\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Landeszeughaus Graz\" width=\"300\" height=\"200\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2020\/03\/landeszeughaus-graz-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div> <\/div>Blick in die historische Waffengeschichte der Steiermark. Milit\u00e4r-historisch und an der regionalen Kultur Interessierte kommen auf ihre Kosten.<address><b>Address : <\/b>{marker_address}<\/address><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-red\" href=\"https:\/\/www.stadt-graz.at\/museen-ausstellungen\/landeszeughaus.html\">Read More...<\/a><\/div>","content":"Blick in die historische Waffengeschichte der Steiermark. Milit\u00e4r-historisch und an der regionalen Kultur Interessierte kommen auf ihre Kosten.","address":"Herrengasse 16, 8010 Graz, \u00d6sterreich","location":{"lat":"47.0698185","city":"Graz","state":"Steiermark","country":"\u00d6sterreich","lng":"15.4398788","onclick_action":"marker","redirect_permalink":"https:\/\/www.stadt-graz.at\/museen-ausstellungen\/landeszeughaus.html","zoom":5,"extra_fields":{"post_excerpt":"Blick in die historische Waffengeschichte der Steiermark. Milit\u00e4r-historisch und an der regionalen Kultur Interessierte kommen auf ihre Kosten.","post_content":"Das <strong>Landeszeughaus<\/strong> geh\u00f6rt zu den meist besuchten <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\">Sehensw\u00fcrdigkeiten<\/a> in Graz. Die <strong>gr\u00f6\u00dfte historische Waffenkammer der Welt<\/strong> mit seiner einzigartigen Atmosph\u00e4re zieht gleicherma\u00dfen Einheimische und Touristen in ihren Bann. Auf vier Stockwerken folgt die dicht gedr\u00e4ngte Aufstellung der rund 32.000 Kriegsger\u00e4te (z. B. Harnische, Panzerhemden, Helme, div. Waffen) aus drei Jahrhunderten (15. bis 18. Jhdt). Sie zeigt sich im Wesentlichen im urspr\u00fcnglichen Erscheinungsbild eines R\u00fcsthauses.\r\n\r\nErbaut zwischen 1642 und 1645 von den steirischen Landst\u00e4nden war das heutzutage international ber\u00fchmte Landeszeughaus einst das wichtigste R\u00fcsthaus im S\u00fcdosten des Habsburger-Reiches. Im 17. Jahrhundert wurden zum Schutz des Landes in erster Linie R\u00fcstst\u00fccke f\u00fcr einfache Fu\u00df- und Reitsoldaten eingelagert. Bereits Mitte des 18. Jahrhunderts ist das Landeszeughaus milit\u00e4risch bedeutungslos geworden, blieb aber als Museum erhalten.\r\n\r\n[caption id=\"attachment_1862\" align=\"alignnone\" width=\"696\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2020\/03\/landeszeughaus-pferdeharnisch.jpg\"><img class=\"wp-image-1862 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2020\/03\/landeszeughaus-pferdeharnisch-1024x682.jpg\" alt=\"Landeszeughaus Ausstellung\" width=\"696\" height=\"464\" \/><\/a> Ausstellungst\u00fccke - Pferdeharnisch, Helme, R\u00fcstungen - im Landeszeughaus Graz.[\/caption]\r\n\r\nDie im <strong>urspr\u00fcnglichen Umfeld gelagerten Waffen und Kriegsger\u00e4te<\/strong> stellen noch heute eine historische Besonderheit dar. Denn die meisten anderen Zeugh\u00e4user Europas wurden im Gegensatz zum Grazer Landeszeughaus aufgel\u00f6st. Seit 1892 ist es dem Landesmuseum Joanneum eingegliedert, jedoch wurde nie der Versuch unternommen, dieses Denkmal zu musealisieren. Aus diesem Grund kann man gerade hier die Aufbewahrungsart und Atmosph\u00e4re eines authentischen Zeughauses studieren und erleben.\r\n\r\nhttps:\/\/youtu.be\/11XwFu-PsPg\r\n\r\n[caption id=\"attachment_1861\" align=\"alignright\" width=\"200\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2020\/03\/landeszeughaus-herrengasse.jpg\"><img class=\"wp-image-1861 size-medium\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2020\/03\/landeszeughaus-herrengasse-200x300.jpg\" alt=\"Zeughaus Fassade \" width=\"200\" height=\"300\" \/><\/a> Eingang zum Landeszeughaus in der Herrengasse 16 neben dem Landhaushof in der <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/grazer-altstadt.html\">Grazer Altstadt<\/a>.[\/caption]\r\n<h2>Landeszeughaus \u00d6ffnungszeiten &amp; Erreichbarkeit<\/h2>\r\n<ul>\r\n \t<li>April bis Oktober - von Dienstag bis Sonntag &amp; an Feiertagen von 10 - 17 Uhr ge\u00f6ffnet<\/li>\r\n \t<li>November bis M\u00e4rz - von Dienstag bis Sonntag &amp; an Feiertagen nur im Rahmen von F\u00fchrungen ge\u00f6ffnet<\/li>\r\n<\/ul>\r\n<a href=\"https:\/\/www.stadt-graz.at\/blog\/fuehrungen-in-graz-rundgaenge-touren.html\">F\u00fchrungen<\/a> finden jeweils um 11 und um 14 Uhr auf Deutsch und um 12:30 Uhr auf Englisch statt.\r\n\r\nWeitere Termine &amp; das aktuelle Programm (F\u00fchrungen, Workshops, Kinderf\u00fchrungen): <a href=\"https:\/\/www.museum-joanneum.at\/landeszeughaus\/ihr-besuch\/programm\" target=\"_blank\" rel=\"noopener\">www.museum-joanneum.at\/landeszeughaus\/ihr-besuch\/programm<\/a>\r\n<h2>Landeszeughaus Eintrittspreise<\/h2>\r\n<ul>\r\n \t<li>Erwachsene 10,50 \u20ac<\/li>\r\n \t<li>Gruppen ab 12 Personen, Seniorinnen\/Senioren, Menschen mit Behinderung(en) 9 \u20ac<\/li>\r\n \t<li>Sch\u00fcler, Lehrlinge, Studierende unter 26 Jahren, Pr\u00e4senz- und Zivildiener 4 \u20ac<\/li>\r\n \t<li>Familienkarte (2 Erwachsene und Kinder unter 14 Jahren) 21 \u20ac<\/li>\r\n \t<li>Kinder unter 6 Jahren frei<\/li>\r\n \t<li>F\u00fchrung 2,50 \u20ac<\/li>\r\n<\/ul>\r\nZus\u00e4tzlich gibt es das <a href=\"https:\/\/www.stadt-graz.at\/museen-ausstellungen\/universalmuseum-joanneum.html#joanneumsticket\"><strong>Joanneums-24h- und -48h-Ticket<\/strong><\/a>. Dies berechtigt zum Eintritt in alle 19 Museen des Joanneums in Graz und der Steiermark.\r\n\r\n\r\n\r\n<em>Fotos: Universalmuseum Joanneum \/ N. Lackner<\/em>","post_title":"Landeszeughaus: R\u00fcstungen &#038; Waffen in historischer Umgebung","post_link":"https:\/\/www.stadt-graz.at\/museen-ausstellungen\/landeszeughaus.html","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Landeszeughaus Graz\" width=\"300\" height=\"200\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2020\/03\/landeszeughaus-graz-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Museen &amp; Ausstellungen, Sehensw\u00fcrdigkeiten in Graz","post_tags":"Altstadt, Kultur","%_edit_lock%":"1690708095:1","%_edit_last%":"1","%post_views_count%":"8342","%_thumbnail_id%":"1854","%_et_monarch_override%":"","%tdc_dirty_content%":"1","%tdc_icon_fonts%":"","%tdc_google_fonts%":"","%_yoast_wpseo_content_score%":"90","%td_post_theme_settings%":"Blick in die historische Waffengeschichte der Steiermark. Im Landeszeughaus kommen Milit\u00e4r-historisch Interessierte sowie Besucher, die an der regionalen Kultur des Landes interessiert sind, auf ihre Kosten.","%_yoast_wpseo_metadesc%":"Nur in diesem Museum findest du gut erhaltene, historische Kriegsger\u00e4te in authentischer Umgebung eines ehemaligen R\u00fcsthauses. Gr\u00f6\u00dfte Waffenkammer ...","%_yoast_wpseo_primary_category%":"8","%_oembed_03b15a5383170850758839b6aaf4ad75%":"{{unknown}}","%_oembed_eb7a6af7a997a46a827bd2093c632b69%":"<iframe title=\"Styrian Armory, Landeszeughaus GRAZ\" width=\"696\" height=\"392\" src=\"https:\/\/www.youtube.com\/embed\/pfp5XEtt1Oc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_eb7a6af7a997a46a827bd2093c632b69%":"1583329204","%_oembed_217476c8aaa5f4651b0620a2e73911ac%":"<iframe title=\"Landeszeughaus Graz\" width=\"696\" height=\"392\" src=\"https:\/\/www.youtube.com\/embed\/hBRzX2Mxe7A?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_217476c8aaa5f4651b0620a2e73911ac%":"1583329237","%_oembed_939da432c80dfc1602e45618b9de5045%":"{{unknown}}","%_oembed_a1019a614e86d18dc0b41c1f84a2a692%":"{{unknown}}","%_oembed_26d490f4ac35b190b1d0825841f761d6%":"<iframe title=\"Landeszeughaus Styrian Armory GRAZ\" width=\"696\" height=\"392\" src=\"https:\/\/www.youtube.com\/embed\/11XwFu-PsPg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_26d490f4ac35b190b1d0825841f761d6%":"1690704859","%ratings_users%":"0","%ratings_score%":"0","%ratings_average%":"0","%_yoast_wpseo_title%":"Landeszeughaus Graz: R\u00fcstungen & Waffen in historischer Umgebung","%_yoast_wpseo_focuskw%":"Landeszeughaus","%_yoast_wpseo_linkdex%":"72","%_wpgmp_location_address%":"Herrengasse 16, 8010 Graz, \u00d6sterreich","%_wpgmp_location_city%":"Graz","%_wpgmp_location_state%":"Steiermark","%_wpgmp_location_country%":"\u00d6sterreich","%_wpgmp_metabox_latitude%":"47.0698185","%_wpgmp_metabox_longitude%":"15.4398788","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"3\";i:1;s:1:\"4\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wp_old_date%":"2020-03-04","%_oembed_9ec05714b50d3536eb5e7954fb1ffd7f%":"<iframe title=\"Landeszeughaus Styrian Armory GRAZ\" width=\"1068\" height=\"601\" src=\"https:\/\/www.youtube.com\/embed\/11XwFu-PsPg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_9ec05714b50d3536eb5e7954fb1ffd7f%":"1668680303","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Museen &amp; Ausstellungen, Sehensw\u00fcrdigkeiten in Graz","taxonomy=post_tag":"Altstadt, Kultur","taxonomy=post_format":""},"icon":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png"},"id":1852,"infowindow_disable":false,"categories":[{"icon":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","name":"Sehensw\u00fcrdigkeiten","id":"2","type":"category"}]},{"source":"post","title":"Grazer Schlo\u00dfberg","infowindow_content":"<div class=\"fc-main\"><div class=\"fc-item-title\">Grazer Schlo\u00dfberg <span class=\"fc-badge info\">Sehensw\u00fcrdigkeiten in Graz<\/span><\/div> <div class=\"fc-item-featured_image\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Schlo\u00dfberg Uhrturm Graz\" width=\"300\" height=\"200\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossberg-uhrturm-graz-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div> <\/div>Die beste Aussicht auf die Stadt und Sitz des Grazer Wahrzeichen - der Uhrturm - ein beliebtes Fotomotiv. Erreichbar zu Fu\u00df, per Lift oder mit der Bahn.<address><b>Address : <\/b>{marker_address}<\/address><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-red\" href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html\">Read More...<\/a><\/div>","content":"Die beste Aussicht auf die Stadt und Sitz des Grazer Wahrzeichen - der Uhrturm - ein beliebtes Fotomotiv. Erreichbar zu Fu\u00df, per Lift oder mit der Bahn.","address":"Am Schlossberg, 8010 Graz, \u00d6sterreich","location":{"lat":"47.07626129999999","city":"Graz","state":"Steiermark","country":"\u00d6sterreich","lng":"15.4380671","onclick_action":"marker","redirect_permalink":"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html","zoom":5,"extra_fields":{"post_excerpt":"Die beste Aussicht auf die Stadt und Sitz des Grazer Wahrzeichen - der Uhrturm - ein beliebtes Fotomotiv. Erreichbar zu Fu\u00df, per Lift oder mit der Bahn.","post_content":"Der <strong>Schlo\u00dfberg<\/strong> in <strong>Graz<\/strong> bildet mit 123 Metern H\u00f6he, ausgehend vom <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/grazer-altstadt.html\">Grazer Hauptplatz<\/a>, den h\u00f6chsten nat\u00fcrlichen Punkt der Stadt und bietet einen <a href=\"https:\/\/www.stadt-graz.at\/service\/webcams-graz.html\">360\u00b0 Rundblick<\/a> \u00fcber die <a href=\"\/\">Stadt Graz<\/a> und deren Grenzen hinaus. Ob Besucher, die einen\u00a0<strong>St\u00e4dteausflug in Graz<\/strong> machen, <a href=\"https:\/\/www.stadt-graz.at\/freizeit\">Erholung suchende Grazer oder Familien<\/a>, die einen gemeinsamen\u00a0<a title=\"Ausflug in Graz unternehmen\" href=\"https:\/\/www.stadt-graz.at\/ausfluege\">Ausflug machen m\u00f6chten<\/a>. Der <strong>Schlo\u00dfberg ist ein bekannter Anziehungspunkt<\/strong>\u00a0und bietet verschiedenste M\u00f6glichkeiten f\u00fcr Aktivit\u00e4ten im Zentrum von Graz.\r\n\r\nDie reichhaltige <em>Geschichte des Schlo\u00dfbergs<\/em> lieferte schon Stoff f\u00fcr so manche B\u00fccher. Wir haben alle <a title=\"Graz Sehensw\u00fcrdigkeiten\" href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\">Sehensw\u00fcrdigkeiten<\/a> und\u00a0<em>Entdeckenswertes am Schlo\u00dfberg<\/em> in diesem Artikel mit vielen <em><a href=\"https:\/\/www.stadt-graz.at\/fotos\">Bildern<\/a>\u00a0aus allen Jahreszeiten<\/em> aufgelistet und w\u00fcnschen viel Spa\u00df dabei diesen bei einem Besuch selbst zu erkunden!\r\n\r\n<span class=\"screen-reader-text\">Gel\u00f6scht: <\/span>[toc]\r\n<h2>Geschichte<\/h2>\r\nBeginnen wir mit der <em>Geschichte des Schlo\u00dfbergs<\/em>. Im <strong>12. Jahrhundert<\/strong> wurde auf dem Schlo\u00dfberg eine <strong>Burg<\/strong> errichtet, die der <a href=\"\/\">Stadt Graz<\/a> auch ihren Namen gab. Einer Ableitung aus \"<strong>gradec<\/strong>\" - dem slowenischen Begriff f\u00fcr <em>kleine Burg<\/em>. Da die Burg nie erobert wurde, ist sie im <em>Guinness Buch der Rekorde<\/em> als die <strong>st\u00e4rkste Festung aller Zeiten<\/strong> aufgelistet. Nicht einmal <strong>Napoleon<\/strong> schaffte es im 19. Jahrhundert die Burg einzunehmen. Erst als er durch die Besetzung Wiens 1809 Graz erpresste, Wien zu zerst\u00f6ren, ergab sich die Stadt Graz.\u00a0Bis auf den <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#glockenturm_8211_liesl\">Glockenturm<\/a> und den <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#uhrturm\">Uhrturm<\/a>, die von den Grazern freigekauft wurden, wurde die Burg im Gro\u00dfen und Ganzen abgetragen und gesprengt, eine sogenannte Schleifung. 30 Jahre sp\u00e4ter legte Ludwig Freiherr von Weldenman Spazierwege und einen <strong>romantischen Garten am Schlo\u00dfberg<\/strong> an.\r\n\r\nIm 2. Weltkrieg wurde im Schlo\u00dfberg ein \u00fcber<strong> 6\u00a0Kilometer\u00a0langes Stollensystem<\/strong> angelegt, das neben der milit\u00e4rischen Zentrale bis zu 40.000 Menschen als Luftschutzbunker diente. Zum Teil sind diese Stollen auch heute noch in Verwendung, sie beinhalten unter anderem\u00a0den <strong>Schlo\u00dfberglift<\/strong>,\u00a0die <a href=\"https:\/\/www.stadt-graz.at\/ausfluege\/maerchenbahn-grottenbahn-graz.html\">M\u00e4rchenbahn<\/a>, die <a href=\"https:\/\/www.stadt-graz.at\/ausfluege\/schlossbergrutsche.html\">Schlossbergrutsche<\/a>, die <a href=\"https:\/\/www.stadt-graz.at\/veranstaltungen\">Veranstaltungshalle \"Dom im Berg\"<\/a> sowie einen\u00a0Verbindungsweg zwischen Schlo\u00dfbergplatz und dem Karmeliterplatz.\u00a0Seit 1999 geh\u00f6rt der <strong>Grazer Schlo\u00dfberg<\/strong> mit der <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/grazer-altstadt.html\">historischen Altstadt von Graz<\/a> zum UNESCO Weltkulturerbe.\r\n<h2>Schlo\u00dfbergmuseum<\/h2>\r\n<img class=\"alignnone size-large wp-image-2334\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossbergmuseum-modell-7508-1024x682.jpg\" alt=\"Schlossbergmuseum Modell\" width=\"696\" height=\"464\" \/>\r\n\r\nSeit der offiziellen Er\u00f6ffnung des neuen Schlo\u00dfbergmuseums (<a href=\"https:\/\/www.stadt-graz.at\/museen-ausstellungen\/graz-museum-schlossberg.html\">Graz Museum Schlo\u00dfberg<\/a>) am 12. September 2020, k\u00f6nnen Besucher des Grazer Stadtberges die Geschichte des Schlo\u00dfberges und seine Bedeutung f\u00fcr Graz kennen lernen. Dazu wurde der Bereich rund um die dortigen Geb\u00e4ude und der Kanonenbastei umgestaltet. Der <strong>Eintritt kostet 4 Euro <\/strong>f\u00fcr Erwachsene (Erm\u00e4\u00dfigt 2 Euro, bis 19 Jahre Eintritt frei).\r\n\r\nDas familienfreundliche Schlo\u00dfbergmuseum ist vollst\u00e4ndig <a href=\"https:\/\/www.stadt-graz.at\/ausfluege\/barrierefreie-ausfluege-graz.html\">barrierefrei<\/a> und bietet auch blinden und sehbehinderten Personen attraktive Angebote. Im <strong>Wundergarten<\/strong> k\u00f6nnen Besucher in Ruhe verweilen und Kinder auf Entdeckungsreise gehen. Die <strong>Kanonenhalle<\/strong> bietet eine der sch\u00f6nsten Aussichten auf Graz. \u00dcber einen drehbaren Bildschirm und einer verbundenen Kamera wird die Geschichte der Stadt interaktiv dargestellt. Im <strong>ehemaligen Kanonierhaus<\/strong> werden die wichtigsten Monumente vor allem in ihrer politischen Bedeutung und ihren historischen Zusammenh\u00e4ngen erl\u00e4utert werden. Ein <strong>besonderer H\u00f6hepunkt im neuen Schlo\u00dfbergmuseum ist das eine Art gl\u00e4sernes Schlo\u00dfbergmodell<\/strong> im Inneren der Kasematte eine Ebene unter dem Areal. Multimedial wird hier die Geschichte des Schlossberges erz\u00e4hlt. Sehenswert!\r\n\r\n\u27a1 Mehr zum Thema: <a href=\"https:\/\/www.stadt-graz.at\/museen-ausstellungen\/graz-museum-schlossberg.html\">Graz Museum Schlossberg<\/a>\r\n<h2>Wege auf den Schlo\u00dfberg in Graz<\/h2>\r\nBevor man die <strong>herrliche Aussicht vom Schlo\u00dfberg in Graz<\/strong> genie\u00dfen und die historischen Mauern und Bauwerke bewundern kann, muss man sich nur entscheiden, welchen Weg man auf den Schlo\u00dfberg nimmt. F\u00fcr jeden Besucher, ob gro\u00df oder klein, <a href=\"https:\/\/www.stadt-graz.at\/sport\/fitnessstudios-graz.html\">sportlich<\/a>\u00a0oder mit <a href=\"https:\/\/www.stadt-graz.at\/ausfluege\/barrierefreie-ausfluege-graz.html\">eingeschr\u00e4nkter Bewegung<\/a> bietet der Schlo\u00dfberg passende M\u00f6glichkeiten. <strong>Erreichbar<\/strong> ist der Schlo\u00dfberg und das Grazer Wahrzeichen \u00fcber:\r\n<ul>\r\n \t<li><a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossbergbahn.html\">Schlo\u00dfbergbahn<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#schlossberglift\">Schlo\u00dfberglift<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#260_stufen_bis_zum_uhrturm\">260 Stufen bis zum Uhrturm<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#strasse_wege\">Stra\u00dfen &amp; Wege<\/a><\/li>\r\n<\/ul>\r\n<h2>Schlo\u00dfbergbahn<\/h2>\r\n[caption id=\"attachment_281\" align=\"alignnone\" width=\"1024\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossbergbahn.jpg\"><img class=\"wp-image-281 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossbergbahn-1024x681.jpg\" alt=\"Schlossbergbahn\" width=\"1024\" height=\"681\" \/><\/a> Mit der Schlo\u00dfbergbahn auf den Schlo\u00dfberg - Panorama Aussicht inklusive.[\/caption]\r\n\r\nDie\u00a0<strong>Schlo\u00dfbergbahn<\/strong> ist eine Standseilbahn, die seit 1894 den Berg von der Westseite her erschlie\u00dft. 2004 wurden 2 neue Wagen mit Glasd\u00e4chern in Betrieb genommen, die einen eindrucksvollen Ausblick auf die Stadt w\u00e4hrend der Fahrt bieten. In ca. 4 Minuten Fahrtzeit \u00fcberwindet die Schlo\u00dfbergbahn dabei eine Steigung von ca. 60%. F\u00fcr <a href=\"https:\/\/www.stadt-graz.at\/ausfluege\/ausfluege-kinder-graz.html\">Eltern mit Kinderwagen<\/a> bietet die Bahn Platz genug - aber Achtung: Zum Einstieg in die Bahn m\u00fcssen enge Stufen mit dem Kinderwagen \u00fcberwunden werden.\r\n\r\n\u27a1 Mehr zum Thema: <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossbergbahn.html\">Schlo\u00dfbergbahn - \u00d6ffnungszeiten, Preise &amp; Geschichte<\/a>\r\n<h2>Schlo\u00dfberglift<\/h2>\r\n<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossberglift.jpg\"><img class=\"alignnone size-large wp-image-283\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossberglift-1024x683.jpg\" alt=\"Schlossberglift\" width=\"1024\" height=\"683\" \/><\/a>\r\n\r\nDen <strong>gl\u00e4sernen Schlo\u00dfberglift<\/strong> bringt\u00a0bis zu 15 Personen in einer Kabine (2 davon sind vorhanden) innerhalb 1 1\/2 Minuten auf den <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html\">Schlo\u00dfberg<\/a> etwas oberhalb des <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#uhrturm\">Uhrturms<\/a>. Er wurde im Jahr 2000 durch Nutzung der vorhandenen Stollen <a href=\"https:\/\/www.stadt-graz.at\/ausfluege\/barrierefreie-ausfluege-graz.html\">behindertengerecht<\/a> angelegt. Eine <strong>Fahrt mit dem Lift<\/strong> ist deutlich g\u00fcnstiger als mit der Bahn. Besonders geeignet ist der Schlo\u00dfberglift f\u00fcr Besucher, die besonders schnell auf den Schlo\u00dfberg kommen m\u00f6chten oder Eltern mit einem Kinderwagen.\r\n<h2>260 Stufen bis zum Uhrturm<\/h2>\r\n<strong><a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossberg-stiegen.jpg\"><img class=\"alignleft size-medium wp-image-301\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossberg-stiegen-300x199.jpg\" alt=\"Schlossberg Stiegen Weg\" width=\"300\" height=\"199\" \/><\/a>260 Stufen den Berg hinauf<\/strong>\u00a0f\u00fchrt der im ersten Weltkrieg angelegte\u00a0<a href=\"\/sehenswuerdigkeiten\/schlossberg-graz.html#kriegssteig\">Kriegssteig<\/a>. Beim Aufstieg zum Uhrturm \u00fcber diesen Weg sollten Besucher die eigene <a href=\"https:\/\/www.stadt-graz.at\/sport\/fitnessstudios-graz.html\">Kondition<\/a> ber\u00fccksichtigen und gegebenenfalls Pausen einlegen. Auch der Weg runter vom Schlo\u00dfberg \u00fcber die vielen Stiegen\u00a0hat es in sich. So mancher hat weiche Knie, wieder am Fu\u00df des Schlo\u00dfbergs angelangt.\r\n\r\nIm Rahmen einer winterlichen Sperre werden die Stufen beim Aufgang und bei den Toren geschlossen.\r\n<h2>Stra\u00dfe &amp; Wege<\/h2>\r\nEs f\u00fchren mehrere Wege den Berg hinauf, unter anderem ausgehend vom Karmeliterplatz, sowie auch von der Wickenburggasse auf der Nordseite des Schlo\u00dfbergs. Viele <em>Schlo\u00dfberg Besucher<\/em> w\u00e4hlen beispielsweise die Variante mit der <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#schlossbergbahn\">Schlo\u00dfbergbahn<\/a> oder dem <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#schlossberglift\">Schlo\u00dfberglift<\/a> hinauf zu fahren und nach Ende einer <strong>Schlo\u00dfbergtour<\/strong> gem\u00fctlich \u00fcber die Stra\u00dfe oder den Kriegssteig wieder nach unten zu gelangen. <em>Hinweis: Radfahren am Schlo\u00dfberg ist nicht erlaubt.<\/em>\r\n\r\n[caption id=\"attachment_261\" align=\"alignnone\" width=\"1024\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossberg-uhrturm-graz1.jpg\"><img class=\"wp-image-261 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossberg-uhrturm-graz1-1024x681.jpg\" alt=\"Uhrturm am Schlossberg in Graz\" width=\"1024\" height=\"681\" \/><\/a> Das Wahrzeichen von Graz: Der bekannte Uhrturm am Schlossberg ist eine der zahlreichen Sehensw\u00fcrdigkeiten in Graz.[\/caption]\r\n<h2>Uhrturm<\/h2>\r\n[caption id=\"attachment_335\" align=\"alignnone\" width=\"1024\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/uhrturm-graz-wahrzeichen.jpg\"><img class=\"wp-image-335 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/uhrturm-graz-wahrzeichen-1024x577.jpg\" alt=\"Uhrturm Graz Wahrzeichen\" width=\"1024\" height=\"577\" \/><\/a> Der Grazer Uhrturm - der Stundenzeiger ist gr\u00f6\u00dfer als der Minutenzeiger[\/caption]\r\n\r\nDer noch weit \u00fcber die Stadtgrenzen hinaus sichtbare <strong>Uhrturm\u00a0<\/strong>ist das<strong> Wahrzeichen von Graz<\/strong>. Jahrhunderte zeigt der Uhrturm den Grazer B\u00fcrger und B\u00fcrgerinnen bereits die Zeit an. Anf\u00e4nglich hatte die Uhr am Turm nur einen Zeiger f\u00fcr die Stunde. Erst sp\u00e4ter kam der <strong>Minutenzeiger<\/strong> dazu, dieser wurde aber zur besseren Entscheidung zum <strong>Stundenzeiger<\/strong> <strong>kleiner gestaltet<\/strong>. Jedes Ziffernblatt auf allen vier Seiten des Uhrturms hat einen Durchmesser von mehr als f\u00fcnf Meter.\r\n\r\nDer Uhrturm selbst hat eine lange Vergangenheit. Die erste Nennung als Teil der Festungsanlage am Schlo\u00dfberg erfolgte um 1265. Bereits im Jahr 1560 bekam der <strong>Grazer Uhrturm<\/strong> seine heutige Form. Feuerw\u00e4chter konnten in fr\u00fcheren Zeiten von einem h\u00f6lzernen Wehrgang, der \u00fcber den Zifferbl\u00e4ttern um den T\u00fcrm f\u00fchrt, das Geschehen und etwaige Feuer in Graz sehen.\u00a0Wenn es brannte, warnte die\u00a0Feuerglocke von 1645 je nach Anzahl der Schl\u00e4ge vor Feuer in den verschiedenen Grazer Bezirken.\r\n\r\n[caption id=\"attachment_338\" align=\"alignnone\" width=\"1024\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/uhrturm-graz-schlossberg.jpg\"><img class=\"wp-image-338 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/uhrturm-graz-schlossberg-1024x682.jpg\" alt=\"Uhrturm Schlossberg Rathaus\" width=\"1024\" height=\"682\" \/><\/a> Blick auf den Schlo\u00dfberg mit dem Uhrturm vom Rathaus aus gesehen. Hinter dem Uhrturm sieht man links die Stallbastei mit der Kanonenh\u00fctte und unterhalb des Turms die beflaggte B\u00fcrgerbastei. Rund herum viele gr\u00fcne B\u00e4ume.[\/caption]\r\n\r\n1809 wurde der Uhrturm nach der Belagerung der Franzosen von Grazer B\u00fcrger freigekauft, damit dieser nicht wie die\u00a0restliche Festungsanlage zerst\u00f6rt wurde. Einen \"Schatten\" bekam der Uhrturm im Jahr 2003 -\u00a0in diesem Jahr war Graz die\u00a0Kulturhauptstadt Europas - in Form eines ma\u00dfstabsgetreu nachgebauten Zwillingsturms aus Stahl. Nach dem Ende des <a href=\"https:\/\/www.stadt-graz.at\/kunst-kultur\">Kulturhauptstadt-Jahres<\/a> wurde der \"<em>Uhrturm Schatten<\/em>\" wieder abgebaut und ist heute neben der Autobahn vor der\u00a0Shoppingcity Seiersberg aufgestellt.\u00a0Die <strong>\u00e4lteste Glocke von Graz<\/strong> aus dem Jahr 1382 - die Stundenglocke - befindet sich ebenso im Uhrturm. Sie schl\u00e4gt zu jeder vollen Stunde.\r\n\r\n<strong>Das Uhrwerk im Uhrturm:<\/strong>\r\n\r\nhttps:\/\/www.youtube.com\/watch?v=BFewyHRvKDg\r\n\r\nVom <strong>Uhrturm<\/strong> f\u00fchrt eine gepflasterte Stra\u00dfe entweder weiter hinauf zur <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#stallbastei_mit_kanonenhuette\">Stallbastei<\/a> am Gel\u00e4nde des neuen Schlo\u00dfbergmuseums und zu den <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#kasemattenbuehne\">Kasematten<\/a> (hier befindet sich auch die Bergstation der Schlo\u00dfbergbahn) oder hinunter in die Stadt zum Karmeliterplatz. Auf der Seite befindet sich der Abgang zur <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#buergerbastei\">B\u00fcrgerbastei<\/a> beziehungsweise zum Kriegssteig hinunter zum Schlo\u00dfbergplatz. Ein paar Meter die Stra\u00dfe hinauf neben dem Cafe Restaurant \"Aiola upstairs\" befindet sich der <em>Zugang zum Lift<\/em>.\r\n\r\n<strong>Mehr zum Thema<\/strong>: \ud83d\udc49 <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/uhrturm.html\" target=\"_blank\" rel=\"noopener\">Uhrturm \u2013 Wahrzeichen von Graz<\/a> mit mehr Fotos &amp; Videos | <a href=\"https:\/\/www.stadt-graz.at\/blog\/blumenuhrturm-bunt-geschmuecktes-kunstwerk.html\" target=\"_blank\" rel=\"noopener\">Blumenuhrturm<\/a> | <a href=\"https:\/\/www.stadt-graz.at\/videos\/klanglicht-illumination-grazer-uhrturm.html\" target=\"_blank\" rel=\"noopener\">So zeigte sich der Uhrturm bei Klanglicht am Schlo\u00dfberg<\/a>\r\n\r\nNeben dem h\u00e4ufig fotografierten Uhrturm, dem Wahrzeichen der Stadt Graz, findet man zahlreiche historische Bauwerke am Schlo\u00dfberg:\r\n<h2>Zisterne<\/h2>\r\n<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/zisterne-schlossberg-graz.jpg\"><img class=\"alignright size-medium wp-image-328\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/zisterne-schlossberg-graz-300x188.jpg\" alt=\"Zisterne Schlossberg\" width=\"300\" height=\"188\" \/><\/a>Die gro\u00dfe <strong>Zisterne<\/strong> im obersten Teil des Schlo\u00dfbergs ist\u00a0ein 16 Meter tiefer Kessel mit 5 kreisf\u00f6rmig angelegten Brunnesch\u00e4chten. In denen wurde das Regenwasser von den D\u00e4chern der umliegenden H\u00e4user abgeleitet und gesammelt. Sie fasst 900.000 Liter und dient heute als L\u00f6schwasser-Reserve. Der aus dem Jahr 1739 stammende\u00a0steinerne Brunnenkranz wurde 1897 durch eine schmiedeeiserne Brunnenlaube erg\u00e4nzt.\r\n<h2>T\u00fcrkenbrunnen<\/h2>\r\n[caption id=\"attachment_285\" align=\"alignright\" width=\"300\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/tuerkenbrunnen-schlossberg-graz.jpg\"><img class=\"wp-image-285 size-medium\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/tuerkenbrunnen-schlossberg-graz-300x169.jpg\" alt=\"T\u00fcrkenbrunnen Schlossberg\" width=\"300\" height=\"169\" \/><\/a> T\u00fcrkenbrunnen[\/caption]\r\n\r\nDer\u00a0<strong>T\u00fcrkenbrunnen<\/strong> ist\u00a0ein 94 Meter bis zum Grundwasser der <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/murinsel-graz.html\">Mur<\/a> reichender Brunnen, der w\u00e4hrend Belagerungszeiten die Festung mit Wasser versorgen konnte. Der Brunnen unterhalb der <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#stallbastei_mit_kanonenhuette\">Kanonenbastei<\/a> wurde zwischen\u00a01554 und 1558 anl\u00e4sslich der Neubefestigung des Schlo\u00dfberges unter Leitung des Baumeisters Domenico dell'Allio gegraben.\r\n\r\nDen Namen <em>T\u00fcrkenbrunnen<\/em> erhielt er aufgrund der Annahme, dass gefangen gehaltene T\u00fcrken an der Grabung beteiligt waren.\r\n<h2>Stallbastei mit Kanonenh\u00fctte<\/h2>\r\n[caption id=\"attachment_291\" align=\"alignright\" width=\"300\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/kanone-schlossberg-graz.jpg\"><img class=\"wp-image-291 size-medium\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/kanone-schlossberg-graz-300x200.jpg\" alt=\"Kanone Schlossberg\" width=\"300\" height=\"200\" \/><\/a> Historische Kanone in der Kanonenh\u00fctte. Seit Errichtung des neuen Schlo\u00dfbergmuseums sind die Kanonen nicht mehr wie im Bild aufgestellt.[\/caption]\r\n\r\nDie <strong>Stallbastei<\/strong> <strong>mit<\/strong> <strong>Kanonenh\u00fctte<\/strong>\u00a0ist ein gewaltiger Bau mit \u00fcber 20 Meter hohen und bis zu 6 Meter starken Grundmauern. Wie schon der Name vermutet, enthielt die Bastei Stallungen. Die Kanonenh\u00fctte diente zur Verteidigung, sp\u00e4ter als Gef\u00e4ngnis.\r\n\r\nDiese 3 Bauten stammen vom italienischen Baumeister Domenico dell\u2019Allio und wurden um 1544 erbaut.\r\n<h2>Glockenturm - Liesl<\/h2>\r\n<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/glockenturm-schlossberg.jpg\"><img class=\"alignright wp-image-311\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/glockenturm-schlossberg-214x300.jpg\" alt=\"Glockenturm Schlossberg\" width=\"300\" height=\"420\" \/><\/a>Der\u00a0<strong>Glockenturm<\/strong> ist\u00a0ein\u00a0im Auftrag von Erzherzog Karl II. 1588 erbaute 34 Meter hoher achteckiger Glockenturm, der die bekannte <strong>\"Liesl\"<\/strong> beherbergt. Sie ist die <strong>drittgr\u00f6\u00dfte Glocke der Steiermark<\/strong> und l\u00e4utet t\u00e4glich um 7, 12 und 19 Uhr mit 101 Schl\u00e4gen.\r\n\r\n<em>Wieso 101 Schl\u00e4ge?<\/em> Die Glocke im Turm ist aus 101 Kanonenkugeln der T\u00fcrken gegossen worden. Die Liesl blieb neben dem <a href=\"\/sehenswuerdigkeiten\/schlossberg-graz.html#uhrturm\">Uhrturm<\/a> vor der Zerst\u00f6rung der Franzosen verschont.\u00a0 Unter dem Glockenturm befindet sich ein unter dem Namen \"Bassgeige\" bekannte\u00a0Verlies.\r\n\r\nBeim j\u00e4hrlichen <strong>Grazer Stadtfest<\/strong> werden interessierten B\u00fcrgern <a href=\"https:\/\/www.stadt-graz.at\/blog\/fuehrungen-in-graz-rundgaenge-touren.html\">F\u00fchrungen<\/a> im Glockenturm angeboten. Im Rahmen dieser haben Besucher auch die Gelegenheit die imposante Liesl aus unmittelbarer Entfernung anzusehen.\r\n\r\nDas Glockenl\u00e4uten der Liesl:\r\n<iframe src=\"https:\/\/www.youtube.com\/embed\/WGG47dMfOZE?rel=0&amp;controls=0&amp;showinfo=0\" width=\"420\" height=\"315\" frameborder=\"0\" allowfullscreen=\"allowfullscreen\"><\/iframe>\r\n<h2>Thomaskapelle<\/h2>\r\n<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/thomaskapelle-schlossberg.jpg\"><img class=\"alignright size-medium wp-image-309\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/thomaskapelle-schlossberg-300x200.jpg\" alt=\"Thomaskapelle Schlossberg\" width=\"300\" height=\"200\" \/><\/a>Die <strong>Thomaskapelle<\/strong> ist\u00a0eine Burgkapelle neben dem Glockenturm, die dem Apostel Thomas geweiht worden war, ein urspr\u00fcnglicher Rundbau mit Kupferdach, welches jedoch durch die Franzosen geraubt wurde - das Bauwerk selbst blieb von den Sprengungen verschont. Bis 1810 stand der\u00a0romanischen Rundbau neben dem Glockenturm, welcher\u00a0vermutlich im 11. Jahrhundert erricht worden war.\r\n\r\nDurch die Witterung verfiel die Thomaskapelle\u00a0und wurde teilweise abgetragen. Heute stehen nur noch die Grundmauern neben dem Glockenturm. Unmittelbar verwandt mit St. Thomas ist die Kapelle der Kaiserpfalz in Goslar.\r\n<h2>Major-Hackher-Denkmal<\/h2>\r\n<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/major-hackher-denkmal-schlossberg.jpg\"><img class=\"size-medium wp-image-293 alignright\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/major-hackher-denkmal-schlossberg-300x199.jpg\" alt=\"Major Hackher Denkmal\" width=\"300\" height=\"199\" \/><\/a>Das<strong> Major-Hackher-Denkmal <\/strong>besser bekannt als Hackher-L\u00f6we, zu Ehren des Majors Franz Hackher, der mit ca. 900 Mann den Schlo\u00dfberg gegen ca. 3000 franz\u00f6sische Soldaten verteidigte. Man ehrte ihn mit einem L\u00f6wen, da es kein Bild des Majors gab. Das Denkmal ist am oberen Teil des <a href=\"https:\/\/www.stadt-graz.at\/ausfluege\/parks-gaerten-in-graz.html\">Parks<\/a> zu finden. Von diesem Platz aus haben Besucher eine sch\u00f6ne Aussicht auf den Nord-Osten von Graz.\r\n<h2>Chinesische Pavillion<\/h2>\r\n[caption id=\"attachment_297\" align=\"alignleft\" width=\"300\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/chinesische-pavillon-schlossberg.jpg\"><img class=\"wp-image-297 size-medium\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/chinesische-pavillon-schlossberg-300x199.jpg\" alt=\"Chinesische Pavillon\" width=\"300\" height=\"199\" \/><\/a> Das chinesische Pavillon am verschneiten Schlo\u00dfberg[\/caption]\r\n\r\nDas <strong>Chinesische Pavillon<\/strong>\u00a0ersetzte 1890 eine romanische Weinlaube. An regnerischen Tagen bietet das Pavillion einen trockenen Unterschlupf und an <a href=\"https:\/\/www.stadt-graz.at\/blog\/top-10-sommer-in-graz-tipps.html\">hei\u00dfen Sommertagen Schatten<\/a>. Von diesem romantischen Pl\u00e4tzchen sieht man \u00fcber den Uhrturm auf weite Teile der Grazer Innenstadt bis in die s\u00fcdliche Steiermark.\r\n\r\n&nbsp;\r\n<h2>Bischofstuhl<\/h2>\r\n<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/bischofstuhl-schlossberg.jpg\"><img class=\"alignright wp-image-306 size-medium\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/bischofstuhl-schlossberg-300x169.jpg\" alt=\"Bischofstuhl Schlossberg\" width=\"300\" height=\"169\" \/><\/a>Der\u00a0<strong>Bischofsstuhl<\/strong>\u00a0ist eine steinerne Bank, auf der der Bischof Graf N\u00e1dasdy nach 40j\u00e4hriger Gefangenschaft bei einer Rast verstorben sein soll.\u00a0Die\u00a0steinerne Bank, ein Fundst\u00fcck aus der sp\u00e4tgotischen Epoche der Burg, weist verwitterte Schriftzeichen und gotisches Blendma\u00dfwerk auf der R\u00fcckseite auf.\r\n<h2>Kasemattenb\u00fchne<\/h2>\r\nDie<strong> Kasemattenb\u00fchne<\/strong>\u00a0ist eine in den Kellerr\u00e4umen des Schlosshauptmannhauses gebaute Freilichtb\u00fchne mit mobiler \u00dcberdachung. Diese bietet Platz f\u00fcr <a href=\"https:\/\/www.stadt-graz.at\/veranstaltungen\">ganzj\u00e4hrige Veranstaltungen<\/a> am Schlo\u00dfberg. Im Advent ist hier einer der sch\u00f6nsten <a href=\"https:\/\/www.stadt-graz.at\/advent\/adventmaerkte-graz.html\">Adventm\u00e4rkte von Graz<\/a> zu finden.\r\n<h2>Starcke-Haus<\/h2>\r\n[caption id=\"attachment_295\" align=\"alignnone\" width=\"1024\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/starcke-haus-cafe-restaurant-schlossberg.jpg\"><img class=\"wp-image-295 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/starcke-haus-cafe-restaurant-schlossberg-1024x682.jpg\" alt=\"Starcke Haus Schlossberg\" width=\"1024\" height=\"682\" \/><\/a> Starcke Haus im <a href=\"https:\/\/www.stadt-graz.at\/blog\/top-5-herbst-in-graz-tipps.html\">Herbst<\/a> - Essen &amp; Trinken am Grazer Schlo\u00dfberg[\/caption]\r\n\r\nDas <strong>Starcke-H\u00e4uschen<\/strong> ist\u00a0ein auf den Ruinen des Pulverturms gebautes Winzerhaus mit angelegten Weinterrassen. Der deutsche Hofschauspieler Gustav Starcke bewohnte dieses Haus und widmete dem Schlo\u00dfberg einige Gedichte. Heute befindet sich darin ein <a href=\"https:\/\/www.stadt-graz.at\/gastronomie\">Cafe-Restaurant<\/a>.\r\n<h2>B\u00fcrgerbastei<\/h2>\r\n[caption id=\"attachment_317\" align=\"alignnone\" width=\"1024\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/buergerbastei-schlossberg.jpg\"><img class=\"wp-image-317 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/buergerbastei-schlossberg-1024x577.jpg\" alt=\"B\u00fcrgerbastei Schlossberg\" width=\"1024\" height=\"577\" \/><\/a> Blick auf die ehemalige B\u00fcrgerbastei mit den vielen sch\u00f6nen Blumen und eine herrliche Aussicht auf das Rathaus und die Grazer Altstadt.[\/caption]\r\n\r\nDie <strong>B\u00fcrgerbastei<\/strong>\u00a0unterhalb vom Uhrturm stellt den blumenreichsten Teil des Schlo\u00dfbergs dar. B\u00fcrgerbastei hei\u00dft diese aus dem Grund, da sie zu Kriegszeiten von den Grazer B\u00fcrgern verteidigt werden musste, w\u00e4hrend die restliche Festung dem Landesf\u00fcrsten unterstand.\u00a0Sie\u00a0wurde zwischen 1551 und 1552 vom italienischen Festungsbaumeister Domenico dell\u2019Allio errichtet, aber erst 1556 fertiggestellt.\r\n\r\nDie <strong>B\u00fcrgerbastei am Schlo\u00dfberg<\/strong> wurde 1930 der \u00d6ffentlichkeit zug\u00e4nglich gemacht und ist heute f\u00fcr viele Erholungsuchende Menschen ein angenehmer Platz zum Verweilen. Viele <a href=\"https:\/\/www.stadt-graz.at\/heiraten\">P\u00e4rchen<\/a> machen im Rosengarten gerne <a href=\"https:\/\/www.stadt-graz.at\/fotos\">romantische Aufnahmen<\/a> f\u00fcr die Ewigkeit. Dieser Teil ist entweder \u00fcber eine Abzweigung beim Kriegssteig oder \u00fcber Stufen vor dem <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html#uhrturm\">Uhrturm<\/a> herunter erreichbar.\r\n\r\n[caption id=\"attachment_320\" align=\"alignnone\" width=\"1024\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/rosengarten-uhrturm-schnee.jpg\"><img class=\"wp-image-320 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/rosengarten-uhrturm-schnee-1024x681.jpg\" alt=\"Rosengarten Uhrturm Schlo\u00dfberg Schnee\" width=\"1024\" height=\"681\" \/><\/a> Tief verschneiter Rosengarten im <a href=\"https:\/\/www.stadt-graz.at\/blog\/top-5-winter-in-graz-tipps.html\">Winter<\/a> mit Blick auf den Grazer Uhrturm.[\/caption]\r\n<h2>Herbersteingarten<\/h2>\r\n[caption id=\"attachment_322\" align=\"alignnone\" width=\"1024\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/herbersteingarten-schlossberg-graz.jpg\"><img class=\"wp-image-322 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/herbersteingarten-schlossberg-graz-1024x577.jpg\" alt=\"Herbersteingarten Schlossberg\" width=\"1024\" height=\"577\" \/><\/a> Herbersteingarten \u00fcber den D\u00e4chern von Graz[\/caption]\r\n\r\nDer\u00a0<strong>Herbersteingarten<\/strong>\u00a0ist der vormalige Weingarten der Grafenfamilie Herberstein, der\u00a01930 \u00f6ffentlich zug\u00e4nglich gemacht wurde und nun ein mediterranes Flair \u00fcber der Stadt Graz anbietet.\u00a0Die Terrassenanlage mit ihrer Bepflanzung z\u00e4hlt zu den sch\u00f6nsten Beispielen der Gartenarchitektur der Zwischenkriegszeit. Fr\u00fcher gab es sogar einen Felsensteig direkt vom Palais der\u00a0Herbersteins in der Sackstra\u00dfe bis zum Weingarten am Schlo\u00dfberg. Hier l\u00e4sst sich mitten in den G\u00e4rten in Ruhe ein gutes Buch lesen oder die <a href=\"https:\/\/www.stadt-graz.at\/blog\/top-10-sommer-in-graz-tipps.html\">Nachmittagssonne \u00fcber Graz genie\u00dfen<\/a>.\r\n<h2>Kriegssteig<\/h2>\r\n[caption id=\"attachment_300\" align=\"alignright\" width=\"200\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/kriegssteig-aufgang-schlossberg.jpg\"><img class=\"wp-image-300 size-medium\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/kriegssteig-aufgang-schlossberg-200x300.jpg\" alt=\"Kriegssteig Schlo\u00dfberg Aufgang\" width=\"200\" height=\"300\" \/><\/a> Aufgang zum Uhrturm auf dem Schlo\u00dfberg \u00fcber 260 Stufen vom Kriegssteig[\/caption]\r\n\r\nDer\u00a0<strong>Kriegssteig<\/strong> mit seinen 260 Stufen, die w\u00e4hrend des ersten Weltkrieges angelegt wurden und vom Schlo\u00dfbergplatz zum Uhrturm hinauf f\u00fchren. Zuletzt wurde im Jahr 2008 eine Umbenennung des Kriegssteiges in Friedenssteig beantragt, aber schlussendlich ist man davon wieder abgekommen.\r\n\r\nBei einer sportlichen Veranstaltung, dem Schlo\u00dfberg Stiegenlauf, erklimmen die besten L\u00e4ufer und L\u00e4uferinnen einen Gro\u00dfteil dieses Steigs sowie den Weg \u00fcber den Rosengarten bis zum Uhrturm in einer Zeit von unter zwei Minuten. Der \"normale\" Spazierg\u00e4nger ben\u00f6tigt daf\u00fcr rund eine Viertelstunde ohne Hektik.\r\n<h2>Graz\u00a0Schlossberg: Erreichbarkeit<\/h2>\r\n<img title=\"Sch\u00f6ne Sicht auf den Schlo\u00dfberg in Graz\" src=\"\/images\/stories\/sehenswuerdigkeiten\/schlossberg-graz.jpg\" alt=\"Schlossberg Graz\" \/>\r\n<img class=\"alignleft\" title=\"Wegweiser zur Schlo\u00dfbergbahn\" src=\"\/images\/stories\/sehenswuerdigkeiten\/graz-schlossbergbahn-wegweiser.jpg\" alt=\"Graz Schlo\u00dfbergbahn\" \/>Die <strong>Stra\u00dfenbahn-Linien 3 und 5<\/strong> halten bei den Haltestellen \"Schlo\u00dfbergbahn\" und \"Schlo\u00dfbergplatz \/ <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/murinsel-graz.html\">Murinsel<\/a>\". Kommt man von der <a href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/grazer-altstadt.html\">Innenstadt<\/a> kann man sich die <a href=\"https:\/\/www.stadt-graz.at\/service\/strassenbahn-bus-graz.html\">Stra\u00dfenbahn<\/a>\u00a0ersparen. Die beiden Haltestellen sind n\u00e4mlich nur 5 beziehungsweise 10 Gehminuten durch die historische Sackstra\u00dfe vorbei am Kaufhaus Kastner &amp; \u00d6hler vom Hauptplatz entfernt. Ein Wegweiser markiert den Weg zur <strong>Schlo\u00dfbergbahn<\/strong> Talstation.\r\n<h3>B\u00fccher \u00fcber den Schlo\u00dfberg in Graz<\/h3>\r\n[amazon template=iframe image&amp;asin=385431633X,3800341735,3854891504,3701200971]","post_title":"Grazer Schlo\u00dfberg","post_link":"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schlossberg-graz.html","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Schlo\u00dfberg Uhrturm Graz\" width=\"300\" height=\"200\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schlossberg-uhrturm-graz-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Sehensw\u00fcrdigkeiten in Graz","post_tags":"Ausflug, Aussicht, Familie, Innenstadt, Schlo\u00dfberg, Schlo\u00dfberglift, Schlo\u00dfbergplatz, Uhrturm, UNESCO, Wanderung","%_edit_last%":"1","%_edit_lock%":"1692036119:1","%ts_template%":"","%_su_rich_snippet_type%":"none","%video_embed%":"","%audio_embed%":"","%ts_sidebar%":"right, 1-4, main","%ts_header_and_footer%":"0, 0, 0","%page_settings%":"","%post_settings%":", no, no, no, no, no, yes, single_style7","%ts_post_rating%":"","%_post_image_gallery%":"","%_touchsize_likes%":"6","%ts_article_views%":"20429","%_thumbnail_id%":"145","%_aioseop_description%":"Grazer Schlo\u00dfberg: Beliebtes Ausflugsziel & Graz Sehensw\u00fcrdigkeit. Infos & Fotos \u00fcber den Schlo\u00dfberg in Graz. Schlo\u00dfbergbahn, Lift, Aufgang","%_oembed_87af38a7feef22701d37eabac14bbdf3%":"<iframe width=\"1333\" height=\"1000\" src=\"https:\/\/www.youtube.com\/embed\/WGG47dMfOZE?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_87af38a7feef22701d37eabac14bbdf3%":"1445528136","%_oembed_5db22d6245d5cda6e31b0b1476fb51e6%":"<iframe width=\"1340\" height=\"754\" src=\"https:\/\/www.youtube.com\/embed\/BFewyHRvKDg?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_5db22d6245d5cda6e31b0b1476fb51e6%":"1481562124","%ts-social-facebook%":"2","%ts-social-count%":"2","%_yoast_wpseo_metadesc%":"Grazer Schlo\u00dfberg ist beliebtestes Ausflugsziel & Sehensw\u00fcrdigkeit in Graz \u2713 Infos Schlo\u00dfbergbahn, Lift, Aufgang \u2713 Tipps \u2713 Schlo\u00dfberg in Graz Foto Rundgang","%_yoast_wpseo_primary_category%":"","%_yoast_wpseo_content_score%":"30","%post_views_count%":"62498","%_oembed_fa5074b042cbd0ef431cdebc51a044c2%":"<iframe title=\"Uhrwerk im Grazer Uhrturm am Schlo\u00dfberg\" width=\"696\" height=\"392\" src=\"https:\/\/www.youtube.com\/embed\/BFewyHRvKDg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_fa5074b042cbd0ef431cdebc51a044c2%":"1692036032","%ratings_users%":"0","%ratings_score%":"0","%ratings_average%":"0","%_et_monarch_override%":"","%tdc_dirty_content%":"1","%tdc_icon_fonts%":"","%tdc_google_fonts%":"","%_yoast_wpseo_title%":"Grazer Schlo\u00dfberg - Beliebtes Ausflugsziel & Sehensw\u00fcrdigkeit in Graz","%_wp_old_date%":"2015-10-14","%_yoast_wpseo_estimated-reading-time-minutes%":"18","%td_post_theme_settings%":"single_template_3","%_wpgmp_location_address%":"Am Schlossberg, 8010 Graz, \u00d6sterreich","%_wpgmp_location_city%":"Graz","%_wpgmp_location_state%":"Steiermark","%_wpgmp_location_country%":"\u00d6sterreich","%_wpgmp_metabox_latitude%":"47.07626129999999","%_wpgmp_metabox_longitude%":"15.4380671","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"3\";i:1;s:1:\"4\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_oembed_55633e71d6467733c68e7bdbcc34aa2f%":"<iframe title=\"Uhrwerk im Grazer Uhrturm am Schlo\u00dfberg\" width=\"1068\" height=\"601\" src=\"https:\/\/www.youtube.com\/embed\/BFewyHRvKDg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_55633e71d6467733c68e7bdbcc34aa2f%":"1618858473","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Sehensw\u00fcrdigkeiten in Graz","taxonomy=post_tag":"Ausflug, Aussicht, Familie, Innenstadt, Schlo\u00dfberg, Schlo\u00dfberglift, Schlo\u00dfbergplatz, Uhrturm, UNESCO, Wanderung","taxonomy=post_format":""},"icon":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png"},"id":12,"infowindow_disable":false,"categories":[{"icon":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","name":"Sehensw\u00fcrdigkeiten","id":"2","type":"category"}]},{"source":"post","title":"Schloss Eggenberg &#8211; UNESCO Weltkulturerbe","infowindow_content":"<div class=\"fc-main\"><div class=\"fc-item-title\">Schloss Eggenberg &#8211; UNESCO Weltkulturerbe <span class=\"fc-badge info\">Sehensw\u00fcrdigkeiten in Graz<\/span><\/div> <div class=\"fc-item-featured_image\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Schloss Eggenberg Graz\" width=\"300\" height=\"200\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schloss-eggenberg-sehenswuerdigkeit-graz-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div> <\/div>Barocke Schlossanlage mit pr\u00e4chtigem Schlosspark, G\u00e4rten und f\u00fcrstlichen Prunkr\u00e4umen. Ein wertvolles Kulturgut & UNESCO Weltkulturerbe.<address><b>Address : <\/b>{marker_address}<\/address><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-red\" href=\"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schloss-eggenberg.html\">Read More...<\/a><\/div>","content":"Barocke Schlossanlage mit pr\u00e4chtigem Schlosspark, G\u00e4rten und f\u00fcrstlichen Prunkr\u00e4umen. Ein wertvolles Kulturgut & UNESCO Weltkulturerbe.","address":"Eggenberger Allee 90, 8020 Graz, \u00d6sterreich","location":{"lat":"47.07266059999999","city":"Graz","state":"Steiermark","country":"\u00d6sterreich","lng":"15.3948384","onclick_action":"marker","redirect_permalink":"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schloss-eggenberg.html","zoom":5,"extra_fields":{"post_excerpt":"Barocke Schlossanlage mit pr\u00e4chtigem Schlosspark, G\u00e4rten und f\u00fcrstlichen Prunkr\u00e4umen. Ein wertvolles Kulturgut & UNESCO Weltkulturerbe.","post_content":"Das <strong>Schloss Eggenberg<\/strong> im Grazer Bezirk Eggenberg ist eine barocke Schlossanlage und eines der <strong>wertvollsten Kulturg\u00fcter in \u00d6sterreich<\/strong>. Am 1.8.2010 wurde das Schloss Eggenberg von der UNESCO in die <strong>Weltkulturerbe<\/strong> Liste aufgenommen. Damit geh\u00f6rt das Schloss in einen Kreis von 900 sch\u00fctzenswerten Denkm\u00e4lern.\r\n\r\n[toc]\r\n\r\nVom Fr\u00fchling bist zum <a href=\"https:\/\/www.stadt-graz.at\/blog\/top-5-winter-in-graz-tipps.html\">Winter<\/a> ist der pr\u00e4chtige <strong>Park vom Schloss Eggenberg<\/strong> ein beliebtes <a href=\"\/freizeit\">Naherholungsziel <\/a>f\u00fcr <a href=\"https:\/\/www.stadt-graz.at\/ausfluege\/ausfluege-kinder-graz.html\">Kinder<\/a> und Erwachsene. Im Schlosspark hat jede Jahreszeit ihren besonderen Reiz. Im <a href=\"https:\/\/www.stadt-graz.at\/blog\/top-5-fruehling-in-graz-tipps.html\">Fr\u00fchling wenn die Gr\u00e4ser und Blumen erbl\u00fchen<\/a> erfreuen sich die Grazer an der aufwachenden Natur, <a href=\"https:\/\/www.stadt-graz.at\/blog\/top-10-sommer-in-graz-tipps.html\">im Sommer<\/a> spenden viele alte B\u00e4ume Schatten an hei\u00dfen Tagen, <a href=\"https:\/\/www.stadt-graz.at\/blog\/top-5-herbst-in-graz-tipps.html\">im Herbst treibt es die Natur im Park besonders bunt<\/a> und wenn es <a href=\"https:\/\/www.stadt-graz.at\/blog\/top-5-winter-in-graz-tipps.html\">im Winter in Graz geschneit hat<\/a>, k\u00f6nnen die St\u00e4dter romantische Spazierg\u00e4nge entlang der verschneiten Wege machen. Wegen der besonderen romantischen Stimmung und der landschaftlichen Sch\u00f6nheit dieser Sehensw\u00fcrdigkeit und der gesch\u00fctzten Anlage, ist der Schloss Eggenberg Park bei vielen <a title=\"Heiraten in Graz\" href=\"https:\/\/www.stadt-graz.at\/heiraten\">Hochzeitspaaren beliebt<\/a>.\r\n<h2>Was gibt es im Schloss Eggenberg zu sehen?<\/h2>\r\n<ul>\r\n \t<li><a href=\"#prunkraueme\">Prunkr\u00e4ume im Schloss<\/a><\/li>\r\n \t<li><a href=\"#park\">Schlosspark und G\u00e4rten<\/a><\/li>\r\n \t<li><a href=\"#alte-galerie\">Alte Galerie<\/a><\/li>\r\n \t<li><a href=\"#archaeologiemuseum\">Arch\u00e4ologiemuseum<\/a><\/li>\r\n \t<li><a href=\"#muenzkabinett\">M\u00fcnzkabinett<\/a><\/li>\r\n<\/ul>\r\nDurch das gro\u00dfe <strong>Tor aus Schmiedeeisen<\/strong> eingefasst in Stein gelangt man in die ber\u00fchmte Schlo\u00dfanlage. Genauer gesagt durch das linke kleinere Seitentor. Direkt am Eingang geben die Allee s\u00e4umenden B\u00e4ume je nach Jahreszeit einen kleineren oder gr\u00f6\u00dferen Blick auf das <strong>einzigartige Schloss<\/strong> frei. Dort befindet sich auch die Kassa, dahinter angeschlossen die\u00a0\u00f6ffentlichen Toiletten.\r\n\r\nhttps:\/\/youtu.be\/7F9EMO5-Clc\r\n\r\nDie bekanntesten Bewohner im\u00a0Schloss Eggenberg Park sind <strong>Pfaue<\/strong> mit ihrem pr\u00e4chtigen Federkleid - die Tiere laufen frei im Park herum und sind <a href=\"https:\/\/www.stadt-graz.at\/fotos\">begehrte Fotomotive in Graz<\/a>. So vertraut den Tieren unser Anblick auch ist, sie wissen einen Abstand zu uns Menschen gerne zu sch\u00e4tzen. Aber hin und wieder traut sich der eine oder andere Pfau doch zu einem Besucher hin, sofern dieser Futter anbieten kann.\r\n<h2>Interessantes \u00fcber das Schloss Eggenberg<\/h2>\r\n[caption id=\"attachment_251\" align=\"alignnone\" width=\"1024\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schloss-eggenberg-unesco.jpg\"><img class=\"wp-image-251 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schloss-eggenberg-unesco-1024x682.jpg\" alt=\"Schloss Eggenberg\" width=\"1024\" height=\"682\" \/><\/a> UNESCO Feier vom Schloss Eggenberg - Das Bild zeigt die Vorderseite des Geb\u00e4udes.[\/caption]\r\n\r\nDas Schloss hat 365 Au\u00dfenfenster, soviele Fenster wie das Jahr Tage hat. 31 R\u00e4ume (wie der l\u00e4ngste Monat) beherbergt jedes Stockwerk, 24 Prunkr\u00e4ume stehen f\u00fcr 24 Stunden. Die 24 Prunkr\u00e4ume haben zudem 52 Fenster und das entspricht die Wochenanzahl im Jahr. Im Planetensaal kommen 12 Monate und 7 Wochentage hinzu. Bereits 1682 gab ein Bildprogramm von Sternzeichen- und- Planetenbildern dem Planetenraum seinen Namen.\r\n\r\n<em>Weitere Details:<\/em>\r\n\r\nIm <span style=\"text-decoration: underline;\">Schlafzimmer<\/span> \u00fcbernachtete 1765 Maria Theresia, Kaisern von \u00d6sterreich,\u00a0f\u00fcr f\u00fcnf Tage in Graz. Noch heute ist das barocke Schlafzimmer im Originalzustand. Das <span style=\"text-decoration: underline;\">R\u00f6mische Zimmer<\/span> ist einer von 24 unver\u00e4nderten Prunkr\u00e4umen mit original barocker Ausstattung. Den Mittelpunkt vom Schloss Eggenberg und \u00e4ltesten Teil vor 1470 stellt die<span style=\"text-decoration: underline;\"> gotische Marienkapelle<\/span> dar. Das <span style=\"text-decoration: underline;\">Gartenzimmer<\/span> ist eines von f\u00fcnf R\u00e4umen mit einer sch\u00f6nen bemalten Wandbespannung aus dem Jahre 1760. Ein japanischer Paravent \u00fcberdauerte im <span style=\"text-decoration: underline;\">japanischen Kabinett<\/span> fast 250 Jahre unerkannt. Im <span style=\"text-decoration: underline;\">Spielzimmer<\/span> stehen Spieltische auf dem die Familie Eggenberg mit Ihren G\u00e4sten Karten spielte.\r\n<h2 id=\"prunkraueme\">Prunkr\u00e4ume Schloss Eggenberg<\/h2>\r\n[caption id=\"attachment_252\" align=\"alignnone\" width=\"1024\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schloss-eggenberg-innenhof.jpg\"><img class=\"wp-image-252 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schloss-eggenberg-innenhof-1024x682.jpg\" alt=\"Innenhof Schloss Eggenberg\" width=\"1024\" height=\"682\" \/><\/a> Imposanter Blick im Innenhof vom Schloss Eggenberg[\/caption]\r\n\r\nSchloss Eggenberg ist ein einzigartiges Gesamtkunstwerk des Barock, in dem sich Architektur und Ausstattung zu einer komplexen symbolischen Darstellung des Universums verbinden. Die Residenz des kaiserlichen Statthalters Hans Ulrich von Eggenberg ist politische Architektur und anspruchsvolle Legitimation f\u00fcr die Herrschaft einer Familie. 2010 wurde Schloss Eggenberg zur UNESCO-Welterbest\u00e4tte erkl\u00e4rt, nicht zuletzt wegen der bedeutenden \u201eBeletage\u201c des Schlosses, deren originale Ausstattung seit dem 18. Jahrhundert nicht mehr ver\u00e4ndert wurde. Der Zyklus von 24 Prunkr\u00e4umen mit pr\u00e4chtigen Wanddekorationen, historischen M\u00f6beln und \u00fcber 500 Deckengem\u00e4lden geh\u00f6rt zu den bedeutendsten Ensembles historischer Innenr\u00e4ume, die \u00d6sterreich besitzt. Im Zentrum: der prunkvolle Planetensaal mit Gem\u00e4lden des Hofmalers Hans Adam Weissenkircher.\r\n<h2 id=\"park\">G\u00e4rten Schloss Eggenberg<\/h2>\r\n[caption id=\"attachment_253\" align=\"alignnone\" width=\"696\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schloss-eggenberg-park.jpg\"><img class=\"wp-image-253 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schloss-eggenberg-park-1024x768.jpg\" alt=\"Schloss Eggenberg Park\" width=\"696\" height=\"522\" \/><\/a> Ein sch\u00f6ner Park mit einem Teich umgibt das Schloss Eggenberg.[\/caption]\r\n\r\nSeit seiner Entstehung im fr\u00fchen 17. Jahrhundert hat der Eggenberger Garten viele Ver\u00e4nderungen erlebt und den jeweiligen Zeitgeschmack reflektiert. Vom barocken Formalgarten der F\u00fcrsten Eggenberg, der das Schloss mit reichen Broderieparterres und Heckenkarrees umgeben hat, sind nur noch wenige Spuren erhalten. Das Schloss liegt heute in einem weitl\u00e4ufigen Landschaftspark aus der Zeit der Romantik, der mit seinem wertvollen Baumbestand zu den kostbarsten Gartendenkmalen des Landes z\u00e4hlt. Zu den Besonderheiten dieses \u201eLandschaftsgem\u00e4ldes\u201c z\u00e4hlen der kunstvolle Rosenh\u00fcgel, der samt Parapluie im chinesischen Stil detailgenau rekonstruiert wurde, und ein kleiner formaler Obstgarten, in dem rund 50 historische Apfel- und Birnensorten an die lange Tradition des Obstbaues im Garten von Schloss Eggenberg erinnern.\r\n<h2 id=\"alte-galerie\">Alte Galerie Schloss Eggenberg<\/h2>\r\n[caption id=\"attachment_2093\" align=\"alignnone\" width=\"696\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/alte-galerie-mittelalter-schloss-eggenberg.jpg\"><img class=\"wp-image-2093 size-large\" title=\"Foto: Universalmuseum Joanneum, N. Lackner\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/alte-galerie-mittelalter-schloss-eggenberg-1024x682.jpg\" alt=\"Alte Galerie Eggenberg\" width=\"696\" height=\"464\" \/><\/a> Die Alte Galerie im Schloss Eggenberg zeigt Kunst vom Mittelalter bis zum sp\u00e4ten 18. Jahrhundert.[\/caption]\r\n\r\nIn 22 S\u00e4len von Schloss Eggenberg pr\u00e4sentiert die Alte Galerie <strong>500 Jahre europ\u00e4ischer Geschichte<\/strong> im Spiegel der Kunst. Abwechslungsreiche Bilderkreise vermitteln dabei \u00fcber die Freude am Sch\u00f6nen auch die eigene kulturelle Vergangenheit: Herausragende Beispiele \u00f6sterreichischer Gotik bezeugen den Glauben des Mittelalters, detailreiche \u201eLesebilder\u201c erz\u00e4hlen vom Leben der fr\u00fchen Neuzeit, erstklassige Zeugnisse der Renaissance sind ebenso zu sehen wie das farbenpr\u00e4chtige Welttheater des Barock. Zu den H\u00f6hepunkten der Alten Galerie z\u00e4hlt die faszinierende \u201eAdmonter Madonna\u201c ebenso wie Meisterwerke von Lucas Cranach d. \u00c4., Pieter Breughel d. J., Johann Georg Platzer und M. J. Schmidt (\u201eKremser Schmidt\u201c).\r\n<h2 id=\"archaeologiemuseum\">Arch\u00e4ologiemuseum Schloss Eggenberg<\/h2>\r\n[caption id=\"attachment_2094\" align=\"alignnone\" width=\"696\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/archaeologiemuseum-schloss-eggenberg.jpg\"><img class=\"wp-image-2094 size-large\" title=\"Foto: Universalmuseum Joanneum, N. Lackner\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/archaeologiemuseum-schloss-eggenberg-1024x682.jpg\" alt=\"Arch\u00e4ologiemuseum\" width=\"696\" height=\"464\" \/><\/a> Das moderne Arch\u00e4ologiemuseum zeigt Funde aus der Steiermark, aus der Antike und aus \u00c4gypten.[\/caption]\r\n\r\nDas moderne Arch\u00e4ologiemuseum im Park von Schloss Eggenberg zeigt mehr als 1.200 Objekte, die als \u201eLebensspuren\u201c Ausgangspunkte f\u00fcr Fragen bilden, die die Menschen seit Jahrtausenden bewegen. H\u00f6hepunkte der Dauerausstellung sind hallstattzeitliche Objekte von Weltrang wie der Kultwagen von Strettweg oder die Maske von Kleinklein, aber auch der wertvollste r\u00f6merzeitliche Fund aus der Steiermark, der Silberbecher von Gr\u00fcnau. Dieses Museum m\u00f6chte alle ansprechen, die sich f\u00fcr Menschen, ihre Lebenswelten, ihre Ausdrucksformen von Religiosit\u00e4t sowie f\u00fcr die wechselnden gesellschaftlichen Bedingungen interessieren. Dar\u00fcber hinaus soll vermittelt werden, wie begrenzt und bruchst\u00fcckhaft unser Wissen \u00fcber die Vergangenheit oft ist \u2013 was manche Fragen offen l\u00e4sst.\r\n<h2 id=\"muenzkabinett\">M\u00fcnzkabinett Schloss Eggenberg<\/h2>\r\n[caption id=\"attachment_2095\" align=\"alignnone\" width=\"696\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/muenzkabinett-schloss-eggenberg.jpg\"><img class=\"wp-image-2095 size-large\" title=\"Foto: Universalmuseum Joanneum, N. Lackner\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/muenzkabinett-schloss-eggenberg-1024x682.jpg\" alt=\"M\u00fcnzausstellung Eggenberg\" width=\"696\" height=\"464\" \/><\/a> Im Schloss Eggenberg befindet sich die zweitgr\u00f6\u00dfte \u00f6ffentliche M\u00fcnzensammlung \u00d6sterreichs.[\/caption]\r\n\r\nM\u00fcnzen sind mehr als Zahlungsmittel \u2013 sie spiegeln detailreich die Politik und Kultur von Gesellschaften. Die M\u00fcnzensammlung des Universalmuseums Joanneum reflektiert die M\u00fcnzgeschichte der Steiermark von der Antike bis ins ausgehende 18. Jahrhundert, u. a. mit faszinierenden Schatzfunden und Prunkst\u00fccken der Pr\u00e4gest\u00e4tte Graz. Die Dauerausstellung des M\u00fcnzkabinetts im \u00e4ltesten Teil von Schloss Eggenberg erz\u00e4hlt einpr\u00e4gsame M\u00fcnzgeschichten aus der Steiermark \u2013 vom Panthertaler der M\u00fcnzst\u00e4tte Graz bis zum Wuschelkopf-Typen der Kelten, von der Goldm\u00fcnze aus Flavia Solva, die zu einem Schmuckst\u00fcck umgearbeitet wurde, bis zum Renaissance-Medaillenkleinod Erzherzog Karls II. von Inner\u00f6sterreich.\r\n<h3>Schloss Eggenberg &amp; Schlosspark \u00d6ffnungszeiten<\/h3>\r\nDie <strong>Prunkr\u00e4ume<\/strong> sind\u00a0nur im Rahmen einer <a href=\"https:\/\/www.stadt-graz.at\/blog\/fuehrungen-in-graz-rundgaenge-touren.html\"><strong>F\u00fchrung<\/strong><\/a> zug\u00e4nglich. Diese werden vom\u00a0April bis Oktober, zwischen Dienstag und Sonntag und an Feiertagen um 10, 11, 12, 14, 15 und 16 Uhr sowie gegen Voranmeldung angeboten. Der\u00a0<strong>Schlosspark<\/strong> und die <strong>G\u00e4rten<\/strong> haben von\u00a0April bis Oktober, t\u00e4glich zwischen 8 und 19 Uhr sowie von\u00a0November bis M\u00e4rz, t\u00e4glich zwischen 8 und 17 Uhr ge\u00f6ffnet.\r\n<h3>Eintrittspreise Schloss Eggenberg und Schlosspark<\/h3>\r\n[caption id=\"attachment_256\" align=\"alignnone\" width=\"1024\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schloss-eggenberg-park-winter-pfau.jpg\"><img class=\"wp-image-256 size-large\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schloss-eggenberg-park-winter-pfau-1024x681.jpg\" alt=\"Schloss Eggenberg Winter\" width=\"1024\" height=\"681\" \/><\/a> Das Schloss Eggenberg pr\u00e4sentiert sich in seiner sch\u00f6nsten winterlichen Pracht. Davor einer der bekannten Pfaue des Parks.[\/caption]\r\n<h4>Schloss Eggenberg:<\/h4>\r\nMit einer Eintrittskarte kann man an einem Tag die Prunkr\u00e4ume, Arch\u00e4ologiemuseum, Alte Galerie und M\u00fcnzkabinett besichtigen. Der Besuch der Prunkr\u00e4ume ist nur im Rahmen einer <strong>F\u00fchrung<\/strong> m\u00f6glich.\r\n<ul>\r\n \t<li>Erwachsene 16 \u20ac<\/li>\r\n \t<li>Gruppen ab 12 Personen, Seniorinnen\/Senioren, Menschen mit Behinderung(en) 14 \u20ac<\/li>\r\n \t<li>Sch\u00fcler, Lehrlinge, Studierende unter 27 Jahren, Pr\u00e4senz- und Zivildiener 6,50 \u20ac<\/li>\r\n \t<li>Familienkarte (2 Erwachsene und Kinder unter 14 Jahren) 32 \u20ac<\/li>\r\n \t<li>Kinder unter 6 Jahren frei<\/li>\r\n<\/ul>\r\n<h4>Schlosspark &amp; G\u00e4rten:<\/h4>\r\n<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2020\/10\/herbstspaziergang-schloss-eggenberg-park.jpg\"><img class=\"alignnone size-large wp-image-2381\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2020\/10\/herbstspaziergang-schloss-eggenberg-park-1024x682.jpg\" alt=\"Herbstspaziergang im Park\" width=\"696\" height=\"464\" \/><\/a>\r\n\r\nMit einer Eintrittskarte nur f\u00fcr den Schlosspark und die angrenzenden G\u00e4rten k\u00f6nnen Besucher diese einen ganzen Tag lang besuchen.\r\n<ul>\r\n \t<li>Erwachsene: 2 \u20ac<\/li>\r\n \t<li>Sch\u00fcler, Lehrlinge, Studierende unter 27 Jahren, Pr\u00e4senz- und Zivildiener: 1 \u20ac<\/li>\r\n \t<li>Jahreskarte Erwachsene: 16 \u20ac<\/li>\r\n \t<li>Jahreskarte Sch\u00fcler, Lehrlinge, Studierende unter 27 Jahren, Pr\u00e4senz- und Zivildiener: 8 \u20ac<\/li>\r\n \t<li>Kindergartengruppen: Eintritt frei<\/li>\r\n \t<li>Kinder unter 6 Jahren. Eintritt frei<\/li>\r\n \t<li>Familien mit dem Zwei und Mehr Steirischen Familienpass: Eintritt frei<\/li>\r\n \t<li>Besitzer einer Joanneumskarte k\u00f6nnen den Schlosspark und die G\u00e4rten ohne Geb\u00fchren besuchen.<\/li>\r\n<\/ul>\r\n<h4>Mehr zum Thema Schloss Eggenberg<\/h4>\r\n[caption id=\"attachment_258\" align=\"alignright\" width=\"300\"]<a href=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/fotografieren-schloss-eggenberg.jpg\"><img class=\"wp-image-258 size-medium\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/fotografieren-schloss-eggenberg-300x199.jpg\" alt=\"Pfau\" width=\"300\" height=\"199\" \/><\/a> Regeln f\u00fcr das Fotografieren im Schloss Eggenberg Park[\/caption]\r\n\r\n<span style=\"text-decoration: underline;\">Ein wichtiger Hinweis f\u00fcr Fotografen:<\/span> Laut dem Universalmuseum Joanneum ist das <a href=\"https:\/\/www.stadt-graz.at\/fotos\">Fotografieren<\/a> und Filmen in <a href=\"https:\/\/www.stadt-graz.at\/museen-ausstellungen\">Ausstellungen<\/a> ausschlie\u00dflich zu privaten Zwecken und nur\u00a0ohne Blitz und Stativ erlaubt. Aufnahmen f\u00fcr Ver\u00f6ffentlichungen sind nur mit vorheriger\u00a0Genehmigung der <a href=\"https:\/\/www.stadt-graz.at\/museen-ausstellungen\/universalmuseum-joanneum.html\">Universalmuseum Joanneum<\/a> GmbH m\u00f6glich. Diese behalten sich aus urheberrechtlichen Gr\u00fcnden\u00a0vor, das Filmen und Fotografieren im Ausstellungsbereich generell zu untersagen.\r\n\r\n[amazon template=iframe image1&amp;asin=390251096X,3800341735]\r\n<h3>Erreichbarkeit Schloss Eggenberg<\/h3>\r\n\r\n\r\nDas Schloss Eggenberg erreicht man einfach mit den \u00f6ffentlichen Verkehrsmitteln, den Stra\u00dfenbahnen der Linie 1 und 7.\r\n<ul>\r\n \t<li><span style=\"text-decoration: underline;\">Linie 1<\/span>: Mit der Stra\u00dfenbahn der Linie 1 bis zur Haltestelle \"Schloss Eggenberg\", anschlie\u00dfend circa 10 Gehminuten die Schlo\u00dfstra\u00dfe entlang bis zum Eingang.<\/li>\r\n \t<li><span style=\"text-decoration: underline;\">Linie 7<\/span>: Mit der Stra\u00dfenbahn der Linie 7 f\u00e4hrt man bis zur Haltestelle \"Franz-Steiner-Gasse\" und geht circa 10 Minuten die Eggenberger Allee entlang bis zum Eingang des Parks.<\/li>\r\n<\/ul>\r\nParkpl\u00e4tze stehen vor dem Schloss als \"Gr\u00fcne Zone\" ausgewiesen ebenso zur Verf\u00fcgung.","post_title":"Schloss Eggenberg &#8211; UNESCO Weltkulturerbe","post_link":"https:\/\/www.stadt-graz.at\/sehenswuerdigkeiten\/schloss-eggenberg.html","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Schloss Eggenberg Graz\" width=\"300\" height=\"200\" src=\"https:\/\/www.stadt-graz.at\/wp-content\/uploads\/2015\/10\/schloss-eggenberg-sehenswuerdigkeit-graz-300x200.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Sehensw\u00fcrdigkeiten in Graz","post_tags":"Eggenberg, Kultur, Park, Schloss, UNESCO","%_edit_last%":"1","%_edit_lock%":"1690708029:1","%ts_template%":"","%_su_rich_snippet_type%":"none","%video_embed%":"","%audio_embed%":"","%ts_sidebar%":"right, 1-4, main","%ts_header_and_footer%":"0, 0, 0","%page_settings%":"","%post_settings%":", no, no, no, no, no, yes, single_style7","%ts_post_rating%":"","%_post_image_gallery%":"","%_touchsize_likes%":"1","%_thumbnail_id%":"131","%ts_article_views%":"6016","%_aioseop_description%":"Sehensw\u00fcrdigkeit Schloss Eggenberg in Graz. Die barocke Schlossanlage ist ein wertvolles Kulturgut in \u00d6sterreich & UNESCO Weltkulturerbe.","%ts-social-twitter%":"1","%ts-social-count%":"2","%_aioseop_title%":"Schloss Eggenberg - UNESCO Weltkulturerbe in Graz","%_yoast_wpseo_metadesc%":"Sehensw\u00fcrdigkeit Schloss Eggenberg in Graz. Die barocke Schlossanlage ist ein wertvolles Kulturgut in \u00d6sterreich & UNESCO Weltkulturerbe.","%_yoast_wpseo_title%":"Schloss Eggenberg - UNESCO Weltkulturerbe in Graz","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_primary_category%":"","%ts-social-facebook%":"1","%post_views_count%":"6731","%ratings_users%":"0","%ratings_score%":"0","%ratings_average%":"0","%_et_monarch_override%":"","%tdc_dirty_content%":"1","%tdc_icon_fonts%":"","%tdc_google_fonts%":"","%_oembed_eee95b56bbe7f5ebf66b42c81e5841ee%":"<iframe title=\"Joanneumsviertel Graz\" width=\"696\" height=\"392\" src=\"https:\/\/www.youtube.com\/embed\/PLqUZJWJZqE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_eee95b56bbe7f5ebf66b42c81e5841ee%":"1583780583","%_oembed_13b512dc6fa2f0fd0778dad15d85235e%":"<iframe title=\"Planetensaal Eggenberg GRAZ\" width=\"696\" height=\"392\" src=\"https:\/\/www.youtube.com\/embed\/7F9EMO5-Clc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_13b512dc6fa2f0fd0778dad15d85235e%":"1690704884","%_yoast_wpseo_estimated-reading-time-minutes%":"10","%td_post_theme_settings%":"single_template_3","%_wpgmp_location_address%":"Eggenberger Allee 90, 8020 Graz, \u00d6sterreich","%_wpgmp_location_city%":"Graz","%_wpgmp_location_state%":"Steiermark","%_wpgmp_location_country%":"\u00d6sterreich","%_wpgmp_metabox_latitude%":"47.07266059999999","%_wpgmp_metabox_longitude%":"15.3948384","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"3\";i:1;s:1:\"4\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"2\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wp_old_date%":"2015-10-14","%_oembed_3c40aba5d995d8d00df61d0c7445f53f%":"<iframe title=\"Planetensaal Eggenberg GRAZ\" width=\"1068\" height=\"601\" src=\"https:\/\/www.youtube.com\/embed\/7F9EMO5-Clc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_3c40aba5d995d8d00df61d0c7445f53f%":"1682869546","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Sehensw\u00fcrdigkeiten in Graz","taxonomy=post_tag":"Eggenberg, Kultur, Park, Schloss, UNESCO","taxonomy=post_format":""},"icon":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png"},"id":10,"infowindow_disable":false,"categories":[{"icon":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","name":"Sehensw\u00fcrdigkeiten","id":"2","type":"category"}]}],"map_property":{"map_id":"3","debug_mode":false},"map_marker_spiderfier_setting":{"minimum_markers":"0"},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"2":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","3":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","4":"https:\/\/www.stadt-graz.at\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png"}}
Hier findest Du:
Als alternativen Online Kartendienst empfehlen wir geodaten.graz.at.
