{"map_options":{"center_lat":"47.481839","center_lng":"-53.1088579","zoom":3,"map_type_id":"ROADMAP","center_by_nearest":false,"fit_bounds":false,"center_circle_fillcolor":"#8CAEF2","center_circle_fillopacity":".5","center_circle_strokecolor":"#8CAEF2","center_circle_strokeopacity":".5","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"http:\/\/majoringinmusic.com\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","center_circle_strokeweight":"1","draggable":true,"scroll_wheel":"true","gesture":"auto","marker_default_icon":"http:\/\/majoringinmusic.com\/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-item-box fc-item-no-padding\">\r\n    {post_featured_image}\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"{post_link}\" class=\"fc-post-link\">{post_title}<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                {post_excerpt}\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/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":"udine","type":"post","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    {post_featured_image}\r\n    &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n        &lt;div class=&quot;fc-item-padding-content_20&quot;&gt;\r\n        &lt;div class=&quot;fc-item-title fc-item-primary-text-color&quot;&gt;&lt;a target=&quot;_blank&quot; href=&quot;{post_link}&quot; class=&quot;fc-post-link&quot;&gt;{post_title}&lt;\/a&gt;&lt;\/div&gt;\r\n            &lt;div class=&quot;fc-item-content fc-item-body-text-color fc-item-top-space&quot;&gt;\r\n                {post_excerpt}\r\n            &lt;\/div&gt;\r\n        &lt;\/div&gt;\r\n    &lt;\/div&gt;\r\n&lt;\/div&gt;"},"infowindow_bounce_animation":"click","infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"default_infowindow_open":false,"infowindow_open_event":"click","listing_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":"0","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":"400"},"places":[{"source":"post","title":"University of Illinois Urbana-Champaign","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Illinois Urbana-Champaign\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2024\/12\/Lead-Photo-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-illinois-urbana-champaign\/\" class=\"fc-post-link\">University of Illinois Urbana-Champaign<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                The University of Illinois School of Music, located in Central Illinois, offers a dynamic and welcoming environment for musicians from all backgrounds.\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","content":"The University of Illinois School of Music, located in Central Illinois, offers a dynamic and welcoming environment for musicians from all backgrounds.","location":{"lat":"40.106271","lng":"-88.223324","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-illinois-urbana-champaign\/","zoom":3,"extra_fields":{"post_excerpt":"The University of Illinois School of Music, located in Central Illinois, offers a dynamic and welcoming environment for musicians from all backgrounds.","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]\r\n<h2><b>University of Illinois School of Music: Where Historic Legacy Meets Cutting-Edge Innovation<\/b><\/h2>\r\nThe University of Illinois School of Music, located in Central Illinois, offers a dynamic and welcoming environment for musicians from all backgrounds. With a history of innovation, including the creation of <strong>the first collegiate Band Program <\/strong>and contributions to computer music, the School blends tradition with cutting-edge practices. Students benefit from world-class faculty, state-of-the-art facilities, and a vibrant academic community that nurtures both musical and scholarly growth.\r\n\r\n<strong>We offer degrees in:<\/strong>\r\n<ul>\r\n \t<li>Computer Science + Music (BS)<\/li>\r\n \t<li>Conducting - Choral, Orchestra, and Wind Band Conducting (MM, DMA)<\/li>\r\n \t<li>Lyric Theatre (BMA)<\/li>\r\n \t<li>Music Composition (BA, BM, MM, DMA)<\/li>\r\n \t<li>Music Education (BME, MME, PhD)<\/li>\r\n \t<li>Music Technology (BA option)<\/li>\r\n \t<li>Musicology (BM, MM, PhD)<\/li>\r\n \t<li>Performance \u2013 Instrumental, Jazz, and Voice (BM, MM, DMA, AD)<\/li>\r\n \t<li>Vocal Coaching and Accompanying (MM, DMA)<\/li>\r\n \t<li>\u2026and create your own degree options! (BM, Open Studies or BA, Music +)<\/li>\r\n<\/ul>\r\nThe School boasts exceptional facilities that support its diverse musical community. Smith Memorial Hall, a registered historical landmark, serves as the heart of the School, combining grandeur with modern amenities. The nearby Krannert Center features six performance venues, rehearsal rooms, and costume shops, with its Foellinger Great Hall known for its remarkable acoustics, hosting well-known artists like Chicago Symphony Orchestra, Thelonious Monk, and many others.\r\n\r\nThe Music Building houses specialized spaces such as <b>the new Hip-Hop Innovation Center<\/b>, Experimental Music Studios, recording studios, and a vast library with nearly a million items. Additionally, the A.A. Harding Band Building displays the Carl Busch Historical Instrument Collection and <b>John Philip Sousa\u2019s personal music library.<\/b>\r\n\r\nJoin us at the University of Illinois School of Music through one of our upcoming <a href=\"https:\/\/music.illinois.edu\/admissions\/visit\/\" target=\"_blank\" rel=\"noopener\">visit options<\/a> and build your future in a program where history and innovation come together to shape the next generation of musicians and music leaders![\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=VXsgZAN4h4M\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=LjRVCUN8uY4\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"26478,26479,26480,26481\" img_size=\"600x400\" css=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"148\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"40.106271\" lng=\"-88.223324\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"University of Illinois Urbana-Champaign","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-illinois-urbana-champaign\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Illinois Urbana-Champaign\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2024\/12\/Lead-Photo-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_edit_lock%":"1736621563:9","%_edit_last%":"4","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"","%school_logo%":"26475","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"26477","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<a href=\"https:\/\/music.illinois.edu\/\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a>\r\n<a href=\"https:\/\/music.illinois.edu\/admissions\/undergraduate-programs-and-application\/undergraduate-degrees\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Majors Offered<\/a>\r\n<a href=\"https:\/\/music.illinois.edu\/admissions\/undergraduate-programs-and-application\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Applications &amp; Auditions<\/a>\r\n<a href=\"https:\/\/music.illinois.edu\/admissions\/graduate\/graduate-degrees\/\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a>\r\n<a href=\"https:\/\/music.illinois.edu\/people\/faculty\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a>\r\n<a href=\"https:\/\/registrar.illinois.edu\/tuition-fees\/tuition-fee-rates\/\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a>\r\n<a href=\"https:\/\/music.illinois.edu\/admissions\/financial-aid\/\" target=\"_blank\" rel=\"noopener\">Scholarships &amp; Financial Aid<\/a>\r\n<a href=\"https:\/\/music.illinois.edu\/engagement\/isym\/\" target=\"_blank\" rel=\"noopener\">Illinois Summer Youth Music<\/a>\r\n<a href=\"https:\/\/music.illinois.edu\/people\/alumni\/\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a>\r\n<a href=\"https:\/\/music.illinois.edu\/admissions\/visit\/\" target=\"_blank\" rel=\"noopener\">Visit the School of Music<\/a>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"40.106271","%_wpgmp_metabox_longitude%":"-88.223324","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";i:3;s:1:\"8\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_wpb_post_custom_layout%":"default","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpb_shortcodes_custom_css_updated%":"1","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"548","%_yoast_wpseo_primary_schools_majors%":"622","%_yoast_wpseo_primary_schools_Region%":"348","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_monsterinsights_sitenote_active%":"0","%_oembed_f78f0a95aa0867797922011e7d07cefa%":"<iframe title=\"Electronic and Experimental Music at Illinois\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/VXsgZAN4h4M?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_f78f0a95aa0867797922011e7d07cefa%":"1734467779","%_oembed_7e9fbb757f73658a06f8e18f8b203bc3%":"<iframe title=\"All about Lyric Theatre @ Illinois\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/LjRVCUN8uY4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_7e9fbb757f73658a06f8e18f8b203bc3%":"1734467780","%_thumbnail_id%":"26483","%_yoast_wpseo_content_score%":"60","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Computer Music, Conducting, Early Music\/ Historical Performance, Ethnomusicology, Music &amp; Health, Music Business, Music Education, Music Entrepreneurship, Music Industry, Music Technology, Musical Theatre, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/Production\/Engineering, Scoring, World Music","taxonomy=schools_majors":"Composition &amp; Theory, Computer Music, Ethnomusicology, Experimental Music, Minor in music, Music (B.A.), Music Education, Music Entrepreneurship, Music Industry, Music Technology, Music Therapy, Musical Theatre, Musicology\/ Music History, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/ Production\/ Engineering, Scoring","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":26470,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"Royal Conservatoire of Scotland","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Royal Conservatoire of Scotland\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2024\/11\/RCS-theatre_1-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/royal-conservatoire-of-scotland\/\" class=\"fc-post-link\">Royal Conservatoire of Scotland<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"55.866180","lng":"-4.257660","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/royal-conservatoire-of-scotland\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<h3>[\/vc_column_text][\/vc_column][\/vc_row][vc_row][vc_column][vc_column_text css=\"\"]<strong><span style=\"font-size: 21px;\">The Royal Conservatoire of Scotland (RCS) is a place like nowhere else, powered by performance, its people, and their passion.<\/span><\/strong><\/h3>\r\nEstablished in 1847, RCS is consistently recognised as a global leader in performing arts education <strong>(currently ranked as one of the world\u2019s top ten performing arts education institutions by the QS World University Rankings 2024).<\/strong>\r\n\r\n<strong>With students from 55 countries, specialist staff and active partnerships with all of Scotland\u2019s national arts companies,<\/strong> RCS is a centre of performance offering a learning environment which encourages students to create new work, collaborate with peers across disciplines and develop innovative ideas and grow into artists the world needs.\r\n\r\nRCS graduates are resourceful, highly employable and members of a dynamic community of artists who make a significant impact across the globe. Alumni perform in symphony orchestras, teach in classrooms and conservatoires, produce world-class arts festivals, create iconic set designs, lead cultural organisations and star in Hollywood movies. <strong>Our Music alumni include Patrick Doyle, Karen Cargill, Ryan Bancroft, Svetlina Stoyanova, Sean Shibe, Daniel Ciobanu and Fergus McCreadie.<\/strong>\r\n\r\nLocated in the vibrant city of Glasgow, RCS is a centre of performance, <strong>with purpose-built venues and a learning environment that encourages students to create new work,<\/strong> collaborate with peers across disciplines and develop ideas across a range of platforms, both physical and virtual. As a world-leading conservatoire, RCS attracts some of the finest educators and performers who are united in their commitment to nurturing the next generation of performing and production artists.\r\n\r\n<strong>At RCS, students develop not just their art but their power to use it.<\/strong>[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/GXwaU4-6AsA\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/GrKxL7CeOZk?si=9NYFIi9FTQbUad25\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"26290,26285,26287,26289\" img_size=\"600x400\" onclick=\"\" css=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"60\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"55.866180\" lng=\"-4.257660\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Royal Conservatoire of Scotland","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/royal-conservatoire-of-scotland\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Royal Conservatoire of Scotland\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2024\/11\/RCS-theatre_1-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_edit_lock%":"1732724346:4","%_edit_last%":"4","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"","%school_logo%":"26278","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"26293","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/www.rcs.ac.uk\/\" target=\"_blank\" rel=\"noopener\">Conservatoire Homepage<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/www.rcs.ac.uk\/staff-a-z\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.rcs.ac.uk\/music\/\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/www.rcs.ac.uk\/study\/how-to-apply\/\" target=\"_blank\" rel=\"noopener\">Apply &amp; Audition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.rcs.ac.uk\/study\/fees-funding\/\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/www.rcs.ac.uk\/study\/fees-funding\/scholarships\/\" target=\"_blank\" rel=\"noopener\">Scholarships and Financial Aid<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/www.rcs.ac.uk\/music\/#postgraduate-programmes\" target=\"_blank\" rel=\"noopener\">Postgraduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.rcs.ac.uk\/rcs-ambassadors\/\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.rcs.ac.uk\/study\/summer-schools\/\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.rcs.ac.uk\/study\/international-students\/\" target=\"_blank\" rel=\"noopener\">International Students<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"55.866180","%_wpgmp_metabox_longitude%":"-4.257660","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"5\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_post_custom_layout%":"default","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpb_shortcodes_custom_css_updated%":"1","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"549","%_yoast_wpseo_primary_schools_majors%":"483","%_yoast_wpseo_primary_schools_Region%":"350","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_oembed_f9f0368478b73c8debce47475af99343%":"<iframe title=\"This is what we do - Royal Conservatoire of Scotland\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/GXwaU4-6AsA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_f9f0368478b73c8debce47475af99343%":"1731017986","%_oembed_9336372623c41c710cb0b8f59b58dc5a%":"<iframe title=\"School of Music audition tips with Matthew McAllister\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/GrKxL7CeOZk?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_9336372623c41c710cb0b8f59b58dc5a%":"1731017986","%_thumbnail_id%":"26295","%_wp_old_date%":"2024-11-07","%_monsterinsights_sitenote_active%":"0","%_yoast_wpseo_focuskw%":"Royal Conservatoire of Scotland","%_yoast_wpseo_linkdex%":"58","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Chamber Music, Composition &amp; Theory, Conducting, Early Music\/ Historical Performance, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Early Music\/ Historical Performance, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_Region":"International Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png"},"id":26272,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png","name":"International Music Schools","id":"4","type":"category"}]},{"source":"post","title":"University of Maryland School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Maryland School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2024\/06\/University-of-Maryland-orchestra-lead-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-maryland-school-of-music\/\" class=\"fc-post-link\">University of Maryland School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"39.001130","lng":"-76.937270","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-maryland-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]\r\n<p class=\"intro\"><strong>Only nine miles from the center of Washington, D.C., and 30 miles from downtown Baltimore, the University of Maryland School of Music is innovative, inclusive and community-focused. We offer a professional music education with all of the opportunities provided by a major research institution.<\/strong><\/p>\r\nWhile completing their degree, many students start their professional careers:\r\n\r\n\u2022 Freelancing with local orchestras\r\n\r\n\u2022 Teaching privately\r\n\r\n\u2022 Interning with major arts and humanities organizations such as the Kennedy Center, the \u2028Smithsonian Institution, the Baltimore Symphony Orchestra, and the Library of Congress\r\n\r\n\u2022 Performing in Young Artist Programs\r\n\r\n<strong>Do you desire a program that is highly focused on performance? Would you prefer the flexibility of music study at a high level combined with the freedom to double major?<\/strong> We offer degree options at the undergraduate and graduate level that allow students to pursue music as artists, scholars and educators. In fact, approximately 40% of our undergraduates double major.\r\n\r\nOur exceptionally-maintained music building, The Clarice Smith Performing Arts Center, brings together the Music, Theatre, and Dance departments, a professional presenting organization, and a vast performing arts library to form one of the largest and most advanced university arts centers in the country.\r\n\r\nThrough our partnership with The Clarice, our students regularly work with visiting artists and scholars such as:\r\n\r\n\u2022 Yo-Yo Ma\r\n\u2022 Dawn Upshaw\r\n\u2022 Gilbert Kalish\r\n\u2022 Dakha Brakha\r\n\u2022 Ravi Coltrane\r\n\u2022 Richard Good\r\n\u2022 yMusic\r\n\u2022 St. Lawrence String Quartet\r\n\u2022 JACK Quartet\r\n\r\n<strong>FAST FACTS:<\/strong>\r\n\r\n\u2022 All-Steinway School featuring 103 Steinway pianos in our music building\r\n\r\n\u2022 350+ School of Music performances each year\r\n\r\n\u2022 5:1 Student-Faculty Ratio\r\n\r\n\u2022 6 state-of-the-art performance venues housed in our music building\r\n\r\n\u2022 156,000 musical scores in our Michelle Smith Performing Arts Library\r\n\r\n\u2022 100% job placement rate in the field for graduates of our music education program[\/vc_column_text][vc_column_text css=\"\" el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/ofZnDQ_KpNM?feature=shared\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/ueSq3zlXW_c\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][vc_gallery type=\"image_grid\" images=\"25800,25805,25802,25801\" img_size=\"600x400\" css=\"\"][gravityform id=\"147\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"39.001130\" lng=\"-76.937270\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"University of Maryland School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-maryland-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Maryland School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2024\/06\/University-of-Maryland-orchestra-lead-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%_edit_lock%":"1729025726:4","%_edit_last%":"4","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"","%school_logo%":"25804","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"25803","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/music.umd.edu\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/music.umd.edu\/directory\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.umd.edu\/degrees\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/music.umd.edu\/admissions\/undergraduate\" target=\"_blank\" rel=\"noopener\">Applications<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/music.umd.edu\/admissions\/auditions\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/academiccatalog.umd.edu\/undergraduate\/fees-expenses-financial-aid\/tuition-fees\/\" target=\"_blank\" rel=\"noopener\">Tuition and Fees<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/music.umd.edu\/admissions\/tuition-scholarships-financial-aid\" target=\"_blank\" rel=\"noopener\">Scholarships and Financial Aid<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.umd.edu\/community-engagement\/summer-programs-camps\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/music.umd.edu\/admissions\/graduate\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/apply.music.umd.edu\/portal\/brochure\" target=\"_blank\" rel=\"noopener\">Music School Brochure<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"39.001130","%_wpgmp_metabox_longitude%":"-76.937270","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_wpb_post_custom_layout%":"default","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"549","%_yoast_wpseo_primary_schools_majors%":"483","%_yoast_wpseo_primary_schools_Region%":"349","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpb_shortcodes_custom_css_updated%":"1","%_yoast_wpseo_content_score%":"30","%_thumbnail_id%":"25846","%_yoast_wpseo_focuskw%":"University of Maryland School of Music","%_yoast_wpseo_metadesc%":"The University of Maryland School of Music is innovative, inclusive and community-focused. We offer a professional music education with all of the opportunities provided by a major research institution.","%_yoast_wpseo_linkdex%":"63","%_oembed_cb48d5d0bf2e91b7d092ee85ef35e22d%":"<iframe title=\"About the University of Maryland School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ofZnDQ_KpNM?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_cb48d5d0bf2e91b7d092ee85ef35e22d%":"1719525761","%_monsterinsights_sitenote_active%":"0","%_oembed_83b2eb4a385b906851704b63f5236967%":"<iframe title=\"Virtual Tour of the University of Maryland School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ueSq3zlXW_c?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_83b2eb4a385b906851704b63f5236967%":"1719941089","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Composition &amp; Theory, Conducting, Ethnomusicology, Music Education, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Music Education, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":25818,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Western University Don Wright Faculty of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Western University Don Wright Faculty of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2023\/07\/Western-University-campus-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/western-university-don-wright-faculty-of-music\/\" class=\"fc-post-link\">Western University Don Wright Faculty of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"43.000501","lng":"-81.174944","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/western-university-don-wright-faculty-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<span style=\"font-size: 14pt;\"><b>Study music at Western to make the most of your talents and take your place in the music industry.<\/b> <\/span><b><span style=\"font-size: 14pt;\">An industry that includes performers, agents, engineers, managers, teachers, and entrepreneurs from every business discipline.<\/span>\u00a0\u00a0<\/b>\r\n\r\n<b>Bachelor of Music Programs<\/b> (include private lessons and ensemble participation):\r\n\r\n\u2022 Composition\r\n\r\n\u2022 General Bachelor of Music (Honours)\r\n\r\n\u2022 Music Education\r\n\r\n\u2022 Music Research\r\n\r\n\u2022 Performance\r\n\r\n<b>Bachelor of Arts <\/b>(private lessons and ensemble participation NOT required)\r\n\r\n\u2022 Honors Specialization (Western art music)\r\n\r\n\u2022 Music Administrative Studies (music and business)\r\n\r\n\u2022 Popular Music (songwriting &amp; production)\r\n\r\n<b>Also offered:<\/b>\r\n\r\nCollaborative and Concurrent Programs in Music Recording Arts; Music and Business; and Music combined with other programs (such as computer science, psychology, languages); Music Minors.\r\n\r\n<b>Graduate programs<\/b>\r\n\r\nOur comprehensive graduate programs lead to the MA, MMus, PhD, and DMA degrees in Composition; Music Education; Music Performance; Musicology; Music Theory. A collaborative graduate specialization in <b>music cognition<\/b> is also offered.\r\n\r\n<strong>Our Campus<\/strong>\r\n<div><span style=\"color: #000000;\">At Western, you will join <b>one of the largest, friendliest music faculties on one of Canada's most beautiful and picturesque campuses.<\/b><\/span><span style=\"color: #000000;\"> You will enjoy the academic challenge of a comprehensive university. Nationally recognized scholars, composers, administrators, teachers and performers \u2013 leaders in Canadian music \u2013 engage students in a learning environment equalled by very few institutions.<\/span><\/div>\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/embed\/uxflzcNcneo\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/embed\/i7GVmE85g2E\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"25017,25016,25024,25019\" img_size=\"600x400\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"104\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"43.000501\" lng=\"-81.174944\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Western University Don Wright Faculty of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/western-university-don-wright-faculty-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Western University Don Wright Faculty of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2023\/07\/Western-University-campus-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1719451290:9","%_edit_last%":"9","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"43.000501","%_wpgmp_metabox_longitude%":"-81.174944","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"5\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"","%school_logo%":"25013","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"25018","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/music.uwo.ca\/\" target=\"_blank\" rel=\"noopener\">Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.uwo.ca\/future-students\/undergraduate\/programs\/index.html\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.uwo.ca\/faculty\/index.html\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.uwo.ca\/future-students\/undergraduate\/undergraduate-admissions.html\" target=\"_blank\" rel=\"noopener\">Undergraduate <\/a><a href=\"https:\/\/music.uwo.ca\/future-students\/undergraduate\/undergraduate-admissions.html\" target=\"_blank\" rel=\"noopener\">Application and Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.uwo.ca\/graduate\/how-when-to-apply.html\" target=\"_blank\" rel=\"noopener\">Graduate Application and Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/welcome.uwo.ca\/next-steps\/finances\/index.html\" target=\"_blank\" rel=\"noopener\">Undergraduate Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/grad.uwo.ca\/finances\/index.html\" target=\"_blank\" rel=\"noopener\">Graduate Cost of attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.uwo.ca\/future-students\/undergraduate\/finaid\/future-undergrad.html\" target=\"_blank\" rel=\"noopener\">Financial Aid\/Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.uwo.ca\/graduate\/\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"548","%_yoast_wpseo_primary_schools_majors%":"622","%_yoast_wpseo_primary_schools_Region%":"350","%_thumbnail_id%":"25012","%_yoast_wpseo_focuskw%":"Western University Don Wright Faculty of Music","%_yoast_wpseo_metadesc%":"Study music at Western to make the most of your talents and take your place in the music industry.","%_yoast_wpseo_linkdex%":"54","%_oembed_87a98ccb2811b0c42a07e9f41e06c759%":"<iframe title=\"Morgan\u00a0 \u00b7 Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/uxflzcNcneo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_87a98ccb2811b0c42a07e9f41e06c759%":"1690053385","%_oembed_4b0fc1a868c5be79f524bac6687fb47e%":"<iframe title=\"Kendra\u00a0 \u00b7 Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/i7GVmE85g2E?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_4b0fc1a868c5be79f524bac6687fb47e%":"1690053385","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_f4fc78a15b5c868967ebf57fb57d826b%":"<iframe title=\"Morgan\u00a0 \u00b7 Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/uxflzcNcneo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_f4fc78a15b5c868967ebf57fb57d826b%":"1714821342","%_oembed_16bfa429711087a86bce8465b2a505f0%":"<iframe title=\"Kendra\u00a0 \u00b7 Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/i7GVmE85g2E?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_16bfa429711087a86bce8465b2a505f0%":"1714821342","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Early Music\/ Historical Performance, Music Cognition, Music Education, Musicology, Performance - Instrumental, Performance - Vocal","taxonomy=schools_majors":"Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Composition &amp; Theory, Music (B.A.), Music Cognition, Music Education, Musicology\/ Music History, Performance - Instrumental, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"International Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png"},"id":25008,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png","name":"International Music Schools","id":"4","type":"category"}]},{"source":"post","title":"Case Western Reserve University Department of Music, College of Arts and Sciences","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Case Western Reserve University Department of Music, College of Arts and Sciences\" width=\"600\" height=\"229\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2023\/04\/1-Main-photo-Haydn-Hall-600x229.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/case-western-reserve-university-department-of-music-college-of-arts-and-sciences\/\" class=\"fc-post-link\">Case Western Reserve University Department of Music, College of Arts and Sciences<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"41.50862","lng":"-81.60767","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/case-western-reserve-university-department-of-music-college-of-arts-and-sciences\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<strong>The Department of Music, an academic department within the College of Arts and Sciences, serves undergraduate and graduate students at Case Western Reserve University as well as all students at the Cleveland Institute of Music through our Joint Music Program.<\/strong>\r\n\r\nA top-ranked private research university with programs spanning the arts and sciences, engineering, health sciences, law, management, and social work, CWRU excels in musicology, historical performance practice, and music education. CIM is one of just three independent conservatories in the United States devoted exclusively to classical music performance. For over half a century, these distinguished institutions have used the JMP to share collective resources, focusing on the strengths of each institution.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\nWith diverse music programs, top-notch research and performance opportunities, and the chance to learn from\u2014and get to know\u2014distinguished faculty, you'll find just what you're looking for on our urban campus in the heart of University Circle, an exciting place to <i>study, explore, and engage!<\/i>\r\n\r\nThe faculty and staff welcome your interest in our Undergraduate and Graduate programs as well as<b>\u00a0<\/b>opportunities for non-majors who want to participate in musical activities on campus.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"24799,24796,24827,24797\" img_size=\"600x400\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"145\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"41.50862\" lng=\"-81.60767\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Case Western Reserve University Department of Music, College of Arts and Sciences","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/case-western-reserve-university-department-of-music-college-of-arts-and-sciences\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Case Western Reserve University Department of Music, College of Arts and Sciences\" width=\"600\" height=\"229\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2023\/04\/1-Main-photo-Haydn-Hall-600x229.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1724784689:4","%_edit_last%":"4","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"41.50862","%_wpgmp_metabox_longitude%":"-81.60767","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"","%school_logo%":"24911","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"24795","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<a href=\"https:\/\/case.edu\/artsci\/music\/\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a>\r\n\r\n<a href=\"https:\/\/case.edu\/artsci\/music\/academics\" target=\"_blank\" rel=\"noopener\">Degree Programs Offered\u00a0<\/a>\r\n\r\n<a href=\"https:\/\/case.edu\/artsci\/music\/about\/people\" target=\"_blank\" rel=\"noopener\">Faculty<\/a>\r\n\r\n<a href=\"https:\/\/case.edu\/artsci\/music\/admissions\/undergraduate\" target=\"_blank\" rel=\"noopener\">Undergraduate Applications &amp; Auditions<\/a>\r\n\r\n<a href=\"https:\/\/case.edu\/artsci\/music\/admissions\/graduate\" target=\"_blank\" rel=\"noopener\">Graduate Applications &amp; Auditions<\/a>\r\n\r\n<a href=\"https:\/\/case.edu\/artsci\/music\/general\/joint-music-program\" target=\"_blank\" rel=\"noopener\">Joint Music Program<\/a>\r\n\r\n<a href=\"https:\/\/case.edu\/admission\/tuition-aid\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a>\r\n\r\n<a href=\"https:\/\/case.edu\/artsci\/music\/admissions\/undergraduate\/undergraduate-scholarships\" target=\"_blank\" rel=\"noopener\">Music Scholarship Opportunities<\/a>\r\n\r\n<a href=\"https:\/\/case.edu\/maltzcenter\/\" target=\"_blank\" rel=\"noopener\">Maltz Performing Arts Center<\/a>\r\n\r\n<a href=\"https:\/\/case.edu\/artsci\/music\/news-events\" target=\"_blank\" rel=\"noopener\">News &amp; Events<\/a>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"555","%_yoast_wpseo_primary_schools_majors%":"622","%_yoast_wpseo_primary_schools_Region%":"348","%_thumbnail_id%":"24791","%_oembed_efcbd36ea3d98b559a5d1063a09868e2%":"{{unknown}}","%_wpb_shortcodes_custom_css_updated%":"1","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Early Music\/ Historical Performance, Music Education, Musicology","taxonomy=schools_majors":"Music (B.A.), Music Education","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":24787,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"University of Washington School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Washington School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2023\/04\/U-Washington-campus-600x400.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-washington-school-of-music\/\" class=\"fc-post-link\">University of Washington School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"47.654170","lng":"-122.302610","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-washington-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]Our school is a vibrant laboratory for arts education and practice within one of the world\u2019s most innovative public universities. As a welcoming and inclusive community of artists and scholars, we work together toward a shared mission of academic discovery and creative mastery. With internationally-acclaimed faculty artists, stellar students, and deep ties to regional and national arts organizations, the <strong>UW School of Music is a thriving hub for arts study, production, and performance in the Pacific Northwest.<\/strong>\r\n\r\nWe offer <b>bachelor\u2019s, master\u2019s, and doctoral degrees<\/b> in the following areas, in addition to <b>many non-major opportunities:<\/b>\r\n<ul>\r\n \t<li>Composition<\/li>\r\n \t<li>Conducting<\/li>\r\n \t<li>Ethnomusicology<\/li>\r\n \t<li>Instrumental Performance<\/li>\r\n \t<li>Jazz and Improvised Music<span class=\"Apple-converted-space\">\u00a0<\/span><\/li>\r\n \t<li>Music Education<\/li>\r\n \t<li>Music History and Music Theory<span class=\"Apple-converted-space\">\u00a0<\/span><\/li>\r\n \t<li>Vocal Performance<span class=\"Apple-converted-space\">\u00a0<\/span><\/li>\r\n<\/ul>\r\nFast facts:\r\n<ul>\r\n \t<li><b>7:1<\/b> average student-teacher ratio<\/li>\r\n \t<li><b>16<\/b> undergraduate degrees offered<\/li>\r\n \t<li>Over <b>25<\/b> performing ensembles<\/li>\r\n \t<li><b>$500,000<\/b> awarded in scholarships each year<span class=\"Apple-converted-space\">\u00a0<\/span><\/li>\r\n<\/ul>\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/embed\/oJY89OZ2974\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/embed\/Hl-MzHnASRE\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"24768,24769,24771,24770\" img_size=\"600x400\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"144\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"47.654170\" lng=\"-122.302610\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"University of Washington School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-washington-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Washington School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2023\/04\/U-Washington-campus-600x400.jpeg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1711916888:4","%_edit_last%":"4","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"47.654170","%_wpgmp_metabox_longitude%":"-122.302610","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"4\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"","%school_logo%":"24759","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"24763","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/music.washington.edu\/\">Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.washington.edu\/undergraduate-programs\">Majors offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.washington.edu\/people\/faculty\/area\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.washington.edu\/admissions\">Application and Audition specifics<\/a><\/li>\r\n \t<li><a href=\"https:\/\/admit.washington.edu\/costs\/coa\/\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.washington.edu\/scholarships-and-financial-aid\">Financial Aid\/Scholarship Opportunities<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.washington.edu\/graduate-programs\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.washington.edu\/alumni-news\">Alumni successes<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"549","%_yoast_wpseo_primary_schools_majors%":"483","%_yoast_wpseo_primary_schools_Region%":"351","%_yoast_wpseo_metadesc%":"The University of Washington School of Music is a thriving hub for arts study, production, and performance in the Pacific Northwest.","%_thumbnail_id%":"24761","%_oembed_b0afa26b9fadd94251de00831df9da33%":"<iframe title=\"Peter Nicolas&#039; UW Law class covers cases, chords and copyright\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/oJY89OZ2974?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_b0afa26b9fadd94251de00831df9da33%":"1681927200","%_oembed_27e0e486ae43dec4f4e2367d082332dd%":"<iframe title=\"String Theory: The Synergy of Math and Music in the UW Symphony\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Hl-MzHnASRE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_27e0e486ae43dec4f4e2367d082332dd%":"1681927201","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_1b28656e63deb7105fc140983b52d49b%":"<iframe title=\"Peter Nicolas&#039; UW Law class covers cases, chords and copyright\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/oJY89OZ2974?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_1b28656e63deb7105fc140983b52d49b%":"1714821342","%_oembed_cd04fe977414deb7f84526de159f631f%":"<iframe title=\"String Theory: The Synergy of Math and Music in the UW Symphony\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Hl-MzHnASRE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_cd04fe977414deb7f84526de159f631f%":"1714821343","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Composition &amp; Theory, Conducting, Early Music\/ Historical Performance, Ethnomusicology, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Early Music\/ Historical Performance, Ethnomusicology, Minor in music, Music (B.A.), Music Education, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_Region":"Western US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png"},"id":24756,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png","name":"Western US Music Schools","id":"3","type":"category"}]},{"source":"post","title":"University of Memphis Rudi E. Scheidt School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"U Memphis music school\" width=\"600\" height=\"345\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2022\/07\/U-Memphis-music-school-600x345.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-memphis\/\" class=\"fc-post-link\">University of Memphis Rudi E. Scheidt School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                Study in a city that invents music and creates legends.\r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","content":"Study in a city that invents music and creates legends.","location":{"lat":"35.122420","lng":"-89.936410","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-memphis\/","zoom":3,"extra_fields":{"post_excerpt":"Study in a city that invents music and creates legends.","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]<strong>MEMPHIS IS MUSIC<\/strong>\r\nStudy music in one of America\u2019s most iconic cities, renowned for its innovation, entrepreneurship, and rich cultural heritage.\r\n\r\n<strong>Who is a good fit?\u00a0<\/strong>\r\nStudents who are passionate, curious, and dedicated will thrive at the University of Memphis. Our mid-sized university provides a welcoming environment where a diverse student body can find their home while immersing themselves in the vibrant city of Memphis.\r\n\r\n<strong>Majors offered:\u00a0<\/strong>\r\n\u2022 Composition: BM, MM, MM to DMA, DMA\r\n\u2022 Commercial Music Performance: BA\r\n\u2022 Conducting: MM, MM to DMA, DMA, AD\r\n\u2022 Jazz + Studio Music: BM, MM\r\n\u2022 Music Business: BM\r\n\u2022 Music Education: BM, MM, MAT, PHD\r\n\u2022 Music History: BM, MM, PHD\r\n\u2022 Music Therapy: BM\r\n\u2022 Pedagogy: MM\r\n\u2022 Performance: BM, MM, MM to DMA, DMA, AD\r\n\u2022 Recording Technology: BM\r\n\u2022 Vocology: Graduate Certificate[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/YQxJRzd_VSM?si=kPMLngwnMEVob4tx\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/L3aNVRGQmCc?si=NrJG1ykgRONG21YF\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"23787,23788,23786,23803\" img_size=\"600X400\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"13\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"35.122420\" lng=\"-89.936410\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"University of Memphis Rudi E. Scheidt School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-memphis\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"U Memphis music school\" width=\"600\" height=\"345\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2022\/07\/U-Memphis-music-school-600x345.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1719354020:4","%_edit_last%":"4","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"35.122420","%_wpgmp_metabox_longitude%":"-89.936410","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"","%school_logo%":"23784","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"23790","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<a href=\"https:\/\/www.memphis.edu\/music\/\" target=\"_blank\" rel=\"noopener\">School of Music Home Page<\/a>\r\n<a href=\"https:\/\/www.memphis.edu\/music\/academics\/index.php\" target=\"_blank\" rel=\"noopener\">Undergrad\/Grad Majors Offered<\/a>\r\n<a href=\"https:\/\/www.memphis.edu\/music\/fac-staff\/index.php\" target=\"_blank\" rel=\"noopener\">Faculty<\/a>\r\n<a href=\"https:\/\/www.memphis.edu\/music\/admissions\/index.php\" target=\"_blank\" rel=\"noopener\">Applications Specifics<\/a>\r\n<a href=\"https:\/\/www.memphis.edu\/music\/admissions\/auditioninformation.php\" target=\"_blank\" rel=\"noopener\">Auditions<\/a>\r\n<a href=\"https:\/\/www.memphis.edu\/usbs\/fees\/index.php\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a>\r\n<a href=\"https:\/\/www.memphis.edu\/music\/admissions\/scholarships.php\" target=\"_blank\" rel=\"noopener\">Scholarships &amp; Financial Aid<\/a>\r\n<a href=\"https:\/\/www.memphis.edu\/scheidtsummer\" target=\"_blank\" rel=\"noopener\">Summer Programs\u00a0<\/a>\r\n<a href=\"https:\/\/blogs.memphis.edu\/bluenote\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"549","%_yoast_wpseo_primary_schools_majors%":"539","%_yoast_wpseo_primary_schools_Region%":"348","%_yoast_wpseo_focuskw%":"University of Memphis","%_yoast_wpseo_metadesc%":"Study in a city that invents music and creates legends.","%_yoast_wpseo_linkdex%":"48","%_thumbnail_id%":"23783","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_oembed_a70cbffb34c24942c39dd623a2a24592%":"<iframe title=\"Mazi Presents &amp;ldquo;Hold Fast&amp;rdquo; and Tigerchor Choir Presents &amp;quot;Prisms&amp;quot; - April 21\" src=\"https:\/\/player.vimeo.com\/video\/701866555?h=f71d4504f8&amp;dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_a70cbffb34c24942c39dd623a2a24592%":"1657917253","%_oembed_cbd8bfe396297ffbb4694ead2ab40589%":"<iframe title=\"The University of Memphis Wind Ensemble - April 27\" src=\"https:\/\/player.vimeo.com\/video\/687292078?h=5f818f774a&amp;dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_cbd8bfe396297ffbb4694ead2ab40589%":"1657917253","%_wpb_shortcodes_custom_css_updated%":"1","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_oembed_503d9c4a91e37787ba73dd2bdcd1d102%":"{{unknown}}","%_oembed_d872cf3c37c477224b49418b5d9d8ca1%":"{{unknown}}","%_oembed_ba66bdbc28959de30ff84d9c0d518455%":"{{unknown}}","%_oembed_f24947ac33927c5722f14780d3f4a5e8%":"{{unknown}}","%_oembed_df5f6c4117443c2f140e892422047461%":"{{unknown}}","%_oembed_50b5d2e71edd0389d31657fb1cddb820%":"{{unknown}}","%_oembed_62306e37ea3f8d4bd07a14c97d9cca70%":"<iframe title=\"UofM Campus Visit | Follow the Roar\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/YQxJRzd_VSM?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_62306e37ea3f8d4bd07a14c97d9cca70%":"1719354159","%_oembed_79726c2e049a0e857173019ec5cc262f%":"<iframe title=\"UofM Scheidt Family Performing Arts Center\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/L3aNVRGQmCc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_79726c2e049a0e857173019ec5cc262f%":"1719354159","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Conducting, Music Education, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_majors":"Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Composition &amp; Theory, Conducting, Minor in music, Music (B.A.), Music Business, Music Education, Musicology\/ Music History, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":23763,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"Tiffin University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Tiffin University\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2022\/05\/Tiffin-University-primary-photo-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/tiffin-university\/\" class=\"fc-post-link\">Tiffin University<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"41.119550","lng":"-83.192860","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/tiffin-university\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<strong>Tiffin University\u2019s cutting-edge bachelor\u2019s degree in commercial music balances coursework in musicianship, music technology and music business, so that students build a set of practical and employable skills.<span class=\"Apple-converted-space\">\u00a0 <\/span><\/strong>\r\n\r\nThe program is unique among small private colleges, as TU can give students hands-on opportunities that larger schools may not be able to offer \u2014 and is designed for students whose musical experiences, tastes and aspirations have been underserved by other colleges.\r\n\r\nThe program uses a diversity of musical styles \u2013 including <strong>popular music, jazz, rock, roots and classical music<\/strong> \u2013 to teach musicianship, and is flexibly designed to maximize personal growth, giving students the opportunity to both excel in strength areas and develop secondary skill areas that pertain to their individual career goals. All students develop their musicianship skills at the keyboard and all rhythm section instruments, take courses in music technology and music business, as well as a capstone project individually designed for each student.\r\n\r\nStudents also get to work with professional producers and songwriters on their own creative projects, and Tiffin University also regularly hosts music industry professionals who lead discussions about their work and give demonstrations of their craft.<b><span class=\"Apple-converted-space\">\u00a0<\/span><\/b>[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=-EEAFqUYr0g\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=MJqACpdCZHA\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"23662,23663,23664,23665\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"139\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"41.119550\" lng=\"-83.192860\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Tiffin University","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/tiffin-university\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Tiffin University\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2022\/05\/Tiffin-University-primary-photo-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1707775826:4","%_edit_last%":"4","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"41.119550","%_wpgmp_metabox_longitude%":"-83.192860","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_metadesc%":"Tiffin University\u2019s bachelor\u2019s degree in commercial music helps students build a set of practical and employable skills.\u00a0","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"","%school_logo%":"23659","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"23660","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/www.tiffin.edu\/arts\/\" target=\"_blank\" rel=\"noopener\">Tiffin Arts Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.tiffin.edu\/academics\/school-of-creative-and-media-arts\/commercial-music\/\" target=\"_blank\" rel=\"noopener\">Commercial Music Major<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.tiffin.edu\/arts\/meet-the-staff\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.tiffin.edu\/apply-now\/\" target=\"_blank\" rel=\"noopener\">Tiffin University Application<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.tiffin.edu\/wp-content\/uploads\/2022\/01\/scholarship-audition-guidelines-new-fall-2021_orig.png\" target=\"_blank\" rel=\"noopener\">Audition Specifics<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.tiffin.edu\/admissions\/financial-aid\/tuition-fees\/\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.tiffin.edu\/arts\/scholarships\/\" target=\"_blank\" rel=\"noopener\">Financial Aid\/Scholarship Opportunities<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.tiffin.edu\/arts\/events\/songwriting-music-production-workshop\/\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_thumbnail_id%":"23658","%_yoast_wpseo_focuskw%":"Tiffin University","%_yoast_wpseo_linkdex%":"59","%_yoast_wpseo_primary_schools_degrees%":"479","%_yoast_wpseo_primary_schools_majors%":"539","%_yoast_wpseo_primary_schools_Region%":"348","%_oembed_04b5ebf1f30b218344540ddb1ac010ea%":"<iframe title=\"Music &amp; Arts Scholarships @ Tiffin University | hip hop rock jazz edm pop a cappella gospel industry\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/-EEAFqUYr0g?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_04b5ebf1f30b218344540ddb1ac010ea%":"1652645870","%_oembed_de72cb65acbbc22aabaf720d9e63e438%":"<iframe title=\"Stay Close. Go Far.  TiffinMusic.  | Tiffin University\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/MJqACpdCZHA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_de72cb65acbbc22aabaf720d9e63e438%":"1652645870","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_8d2bc988aa5aa22378b413078c63db38%":"{{unknown}}","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_c8e713cd408410c78793aba347c1d2c9%":"<iframe title=\"Music &amp; Arts Scholarships @ Tiffin University | hip hop rock jazz edm pop a cappella gospel industry\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/-EEAFqUYr0g?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_c8e713cd408410c78793aba347c1d2c9%":"1701556031","%_oembed_a5338119d6ad744cf47f30cddd5dca0a%":"<iframe title=\"Stay Close. Go Far.  TiffinMusic.  | Tiffin University\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/MJqACpdCZHA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_a5338119d6ad744cf47f30cddd5dca0a%":"1701556032","%_monsterinsights_sitenote_active%":"0","taxonomy=post_tag":"","taxonomy=schools_degrees":"Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Computer Music, Electronic Music, Music Business, Music Entrepreneurship, Music Technology, Recording\/ Production\/ Engineering, Scoring","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":23656,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"McGill University Schulich School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"McGill University Schulich School of Music\" width=\"600\" height=\"338\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2021\/08\/McGill-University-Schulich-School-of-Music--600x338.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/mcgill-university-schulich-school-of-music\/\" class=\"fc-post-link\">McGill University Schulich School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"45.494580","lng":"-73.583500","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/mcgill-university-schulich-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<span style=\"font-size: 14pt;\"><b>The Schulich School of Music at McGill University offers an unparalleled standard of education, fostering exceptional performance and cutting-edge research within an inclusive and inspiring atmosphere.\u00a0<\/b><\/span>\r\n<p style=\"font-weight: 400;\">Situated in\u00a0<strong>Montreal, Quebec,<\/strong>\u00a0often hailed as Canada's cultural capital, our school stands as a beacon of musical excellence.<\/p>\r\n<p style=\"font-weight: 400;\">Instruction takes place in English, and <strong>our tuition and fees are notably more affordable than those of many U.S. counterparts.<\/strong><\/p>\r\n<p style=\"font-weight: 400;\"><strong>Undergraduate Majors<\/strong>\r\n\u00b7 Early Music Performance (instrumental or vocal)\r\n\u00b7 Jazz Performance (instrumental or vocal)\r\n\u00b7 Orchestral Instruments Performance\r\n\u00b7 Organ Performance\r\n\u00b7 Piano Performance\r\n\u00b7 Voice Performance\r\n\u00b7 Composition\r\n\u00b7 Music Education\r\n\u00b7 Music History\r\n\u00b7 Music Theory\r\n\u00b7 Faculty Program (Music Studies)\r\n<em>Students can also choose courses from among the vast selection offered across McGill. They can also easily add minors, double majors, or dual degrees.<\/em><\/p>\r\n<p style=\"font-weight: 400;\"><strong>Licentiate in Music<\/strong>\r\nThe three-year Licentiate in Music (L. Mus.) program is a performance-intensive program designed for instrumentalists and singers who wish to concentrate on their practical subjects while limiting theoretical and general academic requirements.<\/p>\r\n<p style=\"font-weight: 400;\"><strong>Graduate Majors (Master\u2019s and Doctorate)<\/strong>\r\n\u00b7 Performance (Classical Instruments and Voice, Jazz, Early Music)\r\n\u00b7 Composition\r\n\u00b7 Music Education\r\n\u00b7 Musicology (Gender &amp; Women\u2019s Studies option)\r\n\u00b7 Music Technology\r\n\u00b7 Music Theory (Gender &amp; Women\u2019s Studies option)\r\n\u00b7 Sound Recording<\/p>\r\n<p style=\"font-weight: 400;\">Within our vibrant community, the Schulich School of Music thrives with 800+ students, 200+ distinguished faculty, numerous ensembles and performance avenues, and robust research and technology initiatives. <strong>Graduates of our programs have taken center stage in leading opera companies, orchestras, music organizations, and academic institutions across the globe<\/strong>, reflecting the profound impact of a Schulich education.<\/p>\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/0a2MfIqg93w?si=XJpY2gafgeStMRWeand\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=zxHLq9-5sMc\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"23985,22868,22869,22870\" img_size=\"600x400\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"135\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"45.494580\" lng=\"-73.583500\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"McGill University Schulich School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/mcgill-university-schulich-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"McGill University Schulich School of Music\" width=\"600\" height=\"338\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2021\/08\/McGill-University-Schulich-School-of-Music--600x338.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1723497564:4","%_edit_last%":"4","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"45.494580","%_wpgmp_metabox_longitude%":"-73.583500","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"5\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"","%school_logo%":"22865","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"22866","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<a href=\"https:\/\/www.mcgill.ca\/music\/\" target=\"_blank\" rel=\"noopener\"><b>Music School Homepage<\/b>\u00a0<\/a>\r\n<a href=\"https:\/\/www.mcgill.ca\/music\/programs\" target=\"_blank\" rel=\"noopener\"><b>Programs Offered<\/b><\/a>\r\n<a href=\"https:\/\/www.mcgill.ca\/music\/people\/field_mprofile_group\/Faculty\" target=\"_blank\" rel=\"noopener\"><b>Faculty<\/b>\r\n<\/a><a href=\"https:\/\/www.mcgill.ca\/music\/admissions\" target=\"_blank\" rel=\"noopener\"><b>Apply &amp; Audition<\/b><\/a><a href=\"https:\/\/www.mcgill.ca\/music\/people\/field_mprofile_group\/Faculty\" target=\"_blank\" rel=\"noopener\">\r\n<\/a><a href=\"https:\/\/www.mcgill.ca\/student-accounts\/tuition-fees\/tuition-and-fees-tables-and-rates\" target=\"_blank\" rel=\"noopener\"><b>Cost of Attendance<\/b><\/a><a href=\"https:\/\/www.mcgill.ca\/music\/people\/field_mprofile_group\/Faculty\" target=\"_blank\" rel=\"noopener\">\r\n<\/a><a href=\"https:\/\/www.mcgill.ca\/music\/admissions\/undergraduate\/finances\" target=\"_blank\" rel=\"noopener\"><b>Undergraduate Costs &amp;\u00a0Scholarships<\/b><\/a><a href=\"https:\/\/www.mcgill.ca\/music\/people\/field_mprofile_group\/Faculty\" target=\"_blank\" rel=\"noopener\">\r\n<\/a><a href=\"https:\/\/www.mcgill.ca\/undergraduate-admissions\/international-students\" target=\"_blank\" rel=\"noopener\"><strong>International Students<\/strong><\/a><a href=\"https:\/\/www.mcgill.ca\/music\/people\/field_mprofile_group\/Faculty\" target=\"_blank\" rel=\"noopener\">\r\n<\/a><a href=\"https:\/\/www.mcgill.ca\/music\/admissions\/visits\" target=\"_blank\" rel=\"noopener\"><b>Visits &amp; Events<\/b>\u00a0<\/a><a href=\"https:\/\/www.mcgill.ca\/music\/people\/field_mprofile_group\/Faculty\" target=\"_blank\" rel=\"noopener\">\r\n<\/a><strong><a href=\"https:\/\/www.mcgill.ca\/music\/resources\/career-planning\" target=\"_blank\" rel=\"noopener\">Career Support<\/a><\/strong>\r\n<a href=\"https:\/\/www.mcgill.ca\/music\/admissions\/discover-schulich\/meet-our-ambassadors\" target=\"_blank\" rel=\"noopener\"><b>Student Ambassadors<\/b><\/a>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"549","%_yoast_wpseo_primary_schools_majors%":"483","%_yoast_wpseo_primary_schools_Region%":"350","%_thumbnail_id%":"22864","%_oembed_08e084dc83708f96ac1332d7adf306ed%":"<iframe title=\"Mahler: Symphony No. 5 - McGill Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/-FvUcjNOVaE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_08e084dc83708f96ac1332d7adf306ed%":"1629146156","%_oembed_750235874cd892bae99b87be523e0f16%":"<iframe title=\"Tom\u00e1s Luis de Victoria: O Vos Omnes - Schulich Singers\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/64yqVB8NQBs?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_750235874cd892bae99b87be523e0f16%":"1629146156","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_1a515fb6d868b91433f306ee9b281b2c%":"<iframe title=\"Mahler: Symphony No. 5 - McGill Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/-FvUcjNOVaE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_1a515fb6d868b91433f306ee9b281b2c%":"1701553388","%_oembed_e28bb783228b6f2548a0fd865b063b09%":"<iframe title=\"Tom\u00e1s Luis de Victoria: O Vos Omnes - Schulich Singers\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/64yqVB8NQBs?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_e28bb783228b6f2548a0fd865b063b09%":"1701553388","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_oembed_e7e363a21b6e13e4e8928debb7ab72a6%":"<iframe title=\"Find your voice in the Jazz Vocal Performance program at Schulich\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/0a2MfIqg93w?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_e7e363a21b6e13e4e8928debb7ab72a6%":"1723497509","%_oembed_7c06db3b42f38a5afa9751dca7384996%":"<iframe title=\"Schulich Singers, McGill Concert Choir and McGill University Chorus | Carmina Burana\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/zxHLq9-5sMc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_7c06db3b42f38a5afa9751dca7384996%":"1723497509","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Chamber Music, Collaborative Piano, Composition &amp; Theory, Conducting, Early Music\/ Historical Performance, Ethnomusicology, Music Cognition, Music Education, Music Technology, Musicology, Opera - Directing, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/Production\/Engineering, Sacred Music","taxonomy=schools_majors":"Arts Management, Chamber Music, Composition &amp; Theory, Conducting, Early Music\/ Historical Performance, Minor in music, Music Education, Music Entrepreneurship, Music Technology, Musicology\/ Music History, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_Region":"International Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png"},"id":22857,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png","name":"International Music Schools","id":"4","type":"category"}]},{"source":"post","title":"University of North Carolina School of the Arts","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"UNCSA music hall\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2021\/02\/UNCSA-music-hall-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-north-carolina-school-of-the-arts\/\" class=\"fc-post-link\">University of North Carolina School of the Arts<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"36.077150","lng":"-80.240240","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-north-carolina-school-of-the-arts\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<strong>The School of Music at the University of North Carolina School of the Arts (UNCSA) is one of five conservatories on one campus that make up the UNCSA arts ecosystem: Music, Dance, Drama, Design &amp; Production and Filmmaking.<\/strong>\r\n\r\nA passion for the arts and creativity unites all students and faculty across the campus. Degree offerings in the School of Music include a Bachelor of Music (BM), a Master of Music (MM), and a post-graduate Professional Artist Certificate (PAC). <em><strong>UNCSA also has a highly regarded residential high school program, offering a high school diploma with a concentration in music.<\/strong><\/em>\r\n\r\nThe conservatory environment at UNCSA provides students with core classical music training in theory, aural skills, keyboard skills, history and literature. These skills combine with performance techniques practiced in weekly lessons, studio classes, chamber ensemble coachings, and large ensemble performances, allowing each student to reach their highest potential as a creative artist.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\nUNCSA produces more than 200 performances and more than 150 of those each year are exclusive to the School of Music. Currently, all performances are livestreamed and available on demand. Our season includes two fully staged operas, chamber music and solo recitals, jazz, wind ensemble, orchestra and choral concerts, composer readings and performances, side-by-side concerts with faculty, and more. Student musicians have the unique opportunity to collaborate with the other conservatories at UNSCA on ballets, musicals, and film score recording sessions.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\nIdeal UNCSA students have a core understanding of music and a passion and work ethic to reach their highest level of potential as performers or composers. Students will receive personalized mentorship from world-renowned faculty, access to state-of-the-art practice rooms, performance venues, recording studios, and faculty and student peers\u2019 support to take creative risks.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/embed\/kTDJ69gr1G8\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/embed\/Z2vSBwBIK7o\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"22256,22255,22258,22257\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"128\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"36.077150\" lng=\"-80.240240\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"University of North Carolina School of the Arts","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-north-carolina-school-of-the-arts\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"UNCSA music hall\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2021\/02\/UNCSA-music-hall-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1706644667:4","%_edit_last%":"4","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"36.077150","%_wpgmp_metabox_longitude%":"-80.240240","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:4:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"6\";i:3;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:2:{i:0;s:1:\"1\";i:1;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_metadesc%":"University of North Carolina School of the Arts (UNCSA) is one of five conservatories on one campus that make up the UNCSA arts ecosystem.","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"","%school_logo%":"22248","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"22253","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/www.uncsa.edu\/music\/index.aspx\" target=\"_blank\" rel=\"noopener\">UNCSA Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.uncsa.edu\/music\/index.aspx\" target=\"_blank\" rel=\"noopener\">Music Majors Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.uncsa.edu\/music\/faculty.aspx\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.uncsa.edu\/admissions\/music\/index.aspx\" target=\"_blank\" rel=\"noopener\">Apply &amp; Audition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.uncsa.edu\/mysa\/current-students\/services\/tuition-and-fees\/index.aspx\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.uncsa.edu\/financialaid\/types-of-aid.aspx\" target=\"_blank\" rel=\"noopener\">Financial Aid<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.uncsa.edu\/high-school\/index.aspx\" target=\"_blank\" rel=\"noopener\">High School Academic Program<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.uncsa.edu\/summer\/music-summer-intensives\/index.aspx\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.uncsa.edu\/music\/alumni\/index.aspx\" target=\"_blank\" rel=\"noopener\">Alumni Stories<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.uncsa.edu\/performances\/index.aspx\" target=\"_blank\" rel=\"noopener\">Performances<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_primary_schools_graduateschools_majors%":"548","%_yoast_wpseo_primary_schools_majors%":"483","%_yoast_wpseo_primary_schools_Region%":"349","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_thumbnail_id%":"22249","%_yoast_wpseo_focuskw%":"University of North Carolina School of the Arts","%_yoast_wpseo_linkdex%":"67","%_oembed_d931790ff3993fe735b332a210400c22%":"<iframe title=\"Breaking Barriers to Music Education During COVID-19\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/kTDJ69gr1G8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_d931790ff3993fe735b332a210400c22%":"1613165906","%_oembed_6f931d9e3cec5dbcd3574f4bc8277422%":"<iframe title=\"Trois Po\u00e8mes de St\u00e9phane Mallarm\u00e9 - Maurice Ravel\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Z2vSBwBIK7o?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_6f931d9e3cec5dbcd3574f4bc8277422%":"1613165906","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_schools_degrees%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_monsterinsights_sitenote_active%":"0","%_oembed_92eca5c66235e11c82b90802e75e01e6%":"<iframe title=\"Breaking Barriers to Music Education During COVID-19\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/kTDJ69gr1G8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_92eca5c66235e11c82b90802e75e01e6%":"1714821343","%_oembed_acd21e56f0e2f7c0b0d53f49098dd515%":"<iframe title=\"Trois Po\u00e8mes de St\u00e9phane Mallarm\u00e9 - Maurice Ravel\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Z2vSBwBIK7o?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_acd21e56f0e2f7c0b0d53f49098dd515%":"1714821343","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Performance - Instrumental, Performance - Vocal, Scoring","taxonomy=schools_majors":"Composition &amp; Theory, Performance - Instrumental, Performance - Vocal","taxonomy=schools_Region":"Arts High Schools, Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerYellow.png"},"id":22244,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"},{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerYellow.png","name":"Arts High Schools","id":"5","type":"category"}]},{"source":"post","title":"Susquehanna University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Susquehanna University campus\" width=\"600\" height=\"401\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2020\/10\/Susquehanna-University-campus-600x401.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/susquehanna-university\/\" class=\"fc-post-link\">Susquehanna University<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"40.797680","lng":"-76.876129","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/susquehanna-university\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<b>The Department of Music at Susquehanna University offers four degree options:<\/b> the Bachelor of Music in Performance, Music Education, or Composition, plus a Bachelor of Arts in Music degree that makes it convenient to double major in Music and virtually any other discipline.\r\n\r\nMusic has been at the heart of Susquehanna since the university was founded more than 160 years ago. With a combination of\u00a0<b>conservatory-level musical training<\/b>\u00a0and a solid foundation in the liberal arts, we make multiple paths in music possible. Our students say that Susquehanna provides\u00a0<b>small-school advantages<\/b>\u00a0as well as\u00a0<b>big-school opportunities<\/b>.\u00a0The facilities in the Cunningham Center for Music and Art,\u00a0filled with large windows and abundant natural light,\u00a0are hard to beat.\u00a0Our premier performance space, Stretansky Concert Hall, is a magnificent 320-seat venue designed specifically for music performance.\r\n\r\nIndividual attention is our hallmark\u2014classes are small. You\u2019ll receive\u00a0<b>intensive mentoring <\/b>from our faculty, who bring extensive real-world experience, impressive credentials, and professional connections. You\u2019ll also interact regularly with guest artists, composers, and leading industry professionals.\r\n\r\nCross-cultural experiences are essential to the liberal arts education and integral for success in today's global society.\u00a0 You are encouraged to take a <b>music-focused trip abroad<\/b> through our award-winning Global Opportunities (GO) program, which requires all students to study away from campus, with 95% of them doing so overseas.\r\n\r\nWe invite you to join a community of musicians whose passion, discipline, and creativity inspire innovative learning and extraordinary performances.\u00a0From the classroom to the recital hall and beyond,\u00a0<b>you\u2019ll be prepared to achieve your personal and professional goals<\/b>.\u00a0Our seniors are regularly accepted to the finest graduate schools. For our Music Education graduates in particular, we see better than 95% job placement annually, even during economic downturns.\r\n\r\nSusquehanna is accredited by the National Association of Schools of Music.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n&nbsp;\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/yqrPSUMIVME\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/jZlx4BIqU4w\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"21765,21767,21766,21777\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"129\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"40.797680\" lng=\"-76.876129\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Susquehanna University","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/susquehanna-university\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Susquehanna University campus\" width=\"600\" height=\"401\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2020\/10\/Susquehanna-University-campus-600x401.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1656442609:4","%_edit_last%":"4","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"40.797680","%_wpgmp_metabox_longitude%":"-76.876129","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_wpb_vc_js_status%":"false","%_yoast_wpseo_content_score%":"30","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"25","%school_logo%":"21763","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"21764","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"http:\/\/www.susqu.edu\/music\" target=\"_blank\" rel=\"noopener\">Music Department Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.susqu.edu\/faculty-staff\" target=\"_blank\" rel=\"noopener\">Music Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.susqu.edu\/admission-and-aid\/apply\" target=\"_blank\" rel=\"noopener\">University Application<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.susqu.edu\/academics\/majors-and-minors\/department-of-music\/audition-information\" target=\"_blank\" rel=\"noopener\">Audition Specifics<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.susqu.edu\/admission-and-aid\/tuition-and-financial-aid\" target=\"_blank\" rel=\"noopener\">Tuition &amp; Financial Aid<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.susqu.edu\/academics\/study-abroad\" target=\"_blank\" rel=\"noopener\">Study Abroad<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.susqu.edu\/academics\/majors-and-minors\/department-of-music\/student-and-alumni-profiles\" target=\"_blank\" rel=\"noopener\">Showcasing Alumni &amp; Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.susqu.edu\/admission-and-aid\/visit\" target=\"_blank\" rel=\"noopener\">Visit Us<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_yoast_wpseo_primary_schools_majors%":"491","%_yoast_wpseo_primary_schools_Region%":"349","%_yoast_wpseo_metadesc%":"With a combination of\u00a0conservatory-level musical training\u00a0and a solid foundation in the liberal arts, Susquehanna makes multiple paths in music possible.","%_oembed_6a707e519e8e1a795c141812019bdcda%":"<iframe title=\"Music Department Highlights\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/yqrPSUMIVME?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_6a707e519e8e1a795c141812019bdcda%":"1603389969","%_oembed_48dfe6992bf0b980edbbcc5cefb9e958%":"<iframe title=\"Student Wind Quintet - Spring 2020\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/jZlx4BIqU4w?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_48dfe6992bf0b980edbbcc5cefb9e958%":"1603389969","%_yoast_wpseo_focuskw%":"Susquehanna University","%_yoast_wpseo_linkdex%":"70","%_thumbnail_id%":"21781","%_yoast_wpseo_estimated-reading-time-minutes%":"","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_f6ca5b7bf51922b167216087a9596bcb%":"<iframe title=\"Music Department Highlights\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/yqrPSUMIVME?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_f6ca5b7bf51922b167216087a9596bcb%":"1701722385","%_oembed_25ddca6ede0b57b4d06f649c38d035a2%":"<iframe title=\"Student Wind Quintet - Spring 2020\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/jZlx4BIqU4w?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_25ddca6ede0b57b4d06f649c38d035a2%":"1701722385","taxonomy=post_tag":"","taxonomy=schools_degrees":"","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Composition &amp; Theory, Music (B.A.), Music Education, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":21750,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Coastal Carolina University Department of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coastal Carolina University student singer\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2020\/10\/Coastal-Carolina-University-student-singer-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/coastal-carolina-university-department-of-music\/\" class=\"fc-post-link\">Coastal Carolina University Department of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"33.796125","lng":"-79.011199","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/coastal-carolina-university-department-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]Join one of the fastest growing music programs on the East Coast! Whether you are a vocalist or instrumentalist, we have a place for you. The <b>Coastal Carolina University Department of Music<\/b> is a fully-accredited member of the National Association of Schools of Music.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\n<b>Undergraduate degree options: <\/b>Performance, Music Education, Commercial Music and Jazz, General Studies<b>. Graduate degree options: <\/b>Music Technology, Music Teaching. <b>Scholarships<\/b> are available for all of our degree options!!<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\nCCU music students receive professional music training, with small class sizes to give individualized attention and numerous performance opportunities. Our diverse and talented faculty provide artist level instruction to all of our students. We embrace technology; and our robust, innovative curriculum prepares all of our graduates to be on the cutting-edge of contemporary music culture.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\nDue to our location, just minutes from one of largest beach resort areas on the East Coast, CCU students have access to hundreds of professional performing and teaching opportunities in our community. The school\u2019s convenient location allows current students to get valuable real-world experience, better preparing them for life after CCU.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\n<b>Our Student Experience<\/b>\r\n<ul>\r\n \t<li>Lower tuition than most college music schools<\/li>\r\n \t<li>Diverse large and small ensemble offerings<\/li>\r\n \t<li>Small class sizes offering individualized instruction<span class=\"Apple-converted-space\">\u00a0<\/span><\/li>\r\n \t<li>The opportunity to work with experienced and diverse faculty<\/li>\r\n \t<li>Unique study abroad opportunities<\/li>\r\n \t<li>Professional teaching opportunities<span class=\"Apple-converted-space\">\u00a0<\/span><\/li>\r\n \t<li>Real world performing experiences<span class=\"Apple-converted-space\">\u00a0<\/span><\/li>\r\n \t<li>State of the art recording facilities<\/li>\r\n<\/ul>\r\n<b>Current CCU music graduates are:<\/b> Broadway performers, music industry professionals, audio engineers, software developers, public school educators, music producers, studio managers, collegiate educators, composers, conductors, orchestral musicians, military band musicians, graduate teaching assistants in prestigious music programs, church music directors, singer-songwriters, orchestra managers, marketing specialists, choreographers, music retailers, web designers, sound technicians, business professionals, private studio teachers, non-profit arts professionals, instrument technicians, piano accompanists, education administrators and much more!<span class=\"Apple-converted-space\">\u00a0<\/span>[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=sIo63ez-di8\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=oah3QWSfAZo\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"21800,21794,21795,21796\" img_size=\"600x400\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"99\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"33.796125\" lng=\"-79.011199\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Coastal Carolina University Department of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/coastal-carolina-university-department-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Coastal Carolina University student singer\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2020\/10\/Coastal-Carolina-University-student-singer-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1736994219:9","%_edit_last%":"4","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"33.796125","%_wpgmp_metabox_longitude%":"-79.011199","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"90","%ultimatum_video%":"","%ultimatum_author%":"false","%majoring-in-music_layout%":"25","%school_logo%":"21746","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"21791","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/www.coastal.edu\/music\/\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.coastal.edu\/music\/faculty\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.coastal.edu\/admissions\/apply\/\" target=\"_blank\" rel=\"noopener\">Application<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.coastal.edu\/music\/audition\/\" target=\"_blank\" rel=\"noopener\">Audition Information\u00a0<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.coastal.edu\/financialaid\/generalinformation\/2023-24costofattendance\/\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.coastal.edu\/financialaid\/\" target=\"_blank\" rel=\"noopener\">Scholarships and Financial Aid<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.coastal.edu\/mamusictech\/\" target=\"_blank\" rel=\"noopener\">Graduate Programs\u00a0<\/a><\/li>\r\n \t<li><a href=\"https:\/\/ccu-music.com\/#alumni\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_thumbnail_id%":"21787","%_yoast_wpseo_focuskw%":"Coastal Caroliina University","%_yoast_wpseo_metadesc%":"Coastal Carolina University music students receive professional music training, with small class sizes to give individualized attention.","%_yoast_wpseo_linkdex%":"59","%_oembed_6a48b2e48a4b22fe273d0ccafbd680e3%":"<iframe title=\"Coastal Now - Virtual Choir Project\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/sIo63ez-di8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_6a48b2e48a4b22fe273d0ccafbd680e3%":"1603741279","%_oembed_c6fabda011fbd8384d9bd01c654098e6%":"<iframe title=\"The Coastal Carolina University Department of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/oah3QWSfAZo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_c6fabda011fbd8384d9bd01c654098e6%":"1603741280","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wpb_shortcodes_custom_css_updated%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_yoast_wpseo_primary_schools_Region%":"","%_oembed_07b3b7fe803ff9cd976f29e82a786409%":"<iframe title=\"Coastal Now - Virtual Choir Project\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/sIo63ez-di8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_07b3b7fe803ff9cd976f29e82a786409%":"1701545935","%_oembed_cee24352705dd7b3a2a0d15dbc8b4875%":"<iframe title=\"The Coastal Carolina University Department of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/oah3QWSfAZo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_cee24352705dd7b3a2a0d15dbc8b4875%":"1701545935","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Music Education, Music Technology","taxonomy=schools_majors":"Music (B.A.), Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":21744,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"West Chester University Wells School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"West Chester University Wells School of Music\" width=\"600\" height=\"300\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2019\/07\/Well-School-of-Music-600x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/west-chester-university-wells-school-of-music\/\" class=\"fc-post-link\">West Chester University Wells School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"39.9533346","lng":"-75.5984492","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/west-chester-university-wells-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"\"><span class=\"\">Explore a career in music at the West Chester University Wells School of Music, accredited with the National Association of Schools of Music. Programs are available in <b class=\"\">Music Performance, Education, Theory, History, Composition, Music with Elective Studies in an Outside Field, and Music Therapy<\/b>.<\/span><\/p>\r\n<p class=\"\"><span class=\"\">With state-of-the-art rehearsal and performing facilities, several scholarship opportunities, and the ability for students also get involved in multiple ensembles, including band, vocal\/choral, orchestra and more, <i class=\"\">Wells School of music is a top choice for an affordable music education<\/i>.<\/span><\/p>\r\n<p class=\"\"><span class=\"\">Wells School of Music alumni consistently tell us that because of the variety of experiences, connections, and faculty mentorship the opportunities are endless for a satisfying future career in the world of music.<\/span><\/p>\r\n<p class=\"\"><span class=\"\">We hope that you will experience in person the vibrancy of our nationally recognized programs of study, and see first-hand the remarkable scholarly and artistic community that is the Wells School of Music at WCU.<\/span><\/p>\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/WjgsGPYmLr8\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/if6BgJan63E\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_gallery type=\"image_grid\" images=\"23009,23010,23012,23011\" img_size=\"600x400\"][\/vc_column_inner][\/vc_row_inner][gravityform id=\"119\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"39.9533346\" lng=\"-75.5984492\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"West Chester University Wells School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/west-chester-university-wells-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"West Chester University Wells School of Music\" width=\"600\" height=\"300\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2019\/07\/Well-School-of-Music-600x300.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1691543695:4","%_edit_last%":"4","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"39.9533346","%_wpgmp_metabox_longitude%":"-75.5984492","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wpb_vc_js_status%":"true","%_yoast_wpseo_content_score%":"60","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"19886","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"23008","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li><a href=\"https:\/\/www.wcupa.edu\/music\/\" target=\"_blank\" rel=\"noopener\">Music School Home Page<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.wcupa.edu\/music\/academics.aspx\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.wcupa.edu\/music\/faculty.aspx\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.wcupa.edu\/music\/prospectiveStu.aspx\" target=\"_blank\" rel=\"noopener\">Application &amp; Audition Specifics<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.wcupa.edu\/_admissions\/SCH_ADM\/costAndAid.aspx\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.wcupa.edu\/music\/prospectiveStu.aspx\" target=\"_blank\" rel=\"noopener\">Scholarship Opportunities for Music<\/a><\/li>\r\n \t<li><a href=\"https:\/\/wcupa.edu\/music\/gradProgram.aspx\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/wcupa.edu\/music\/specialPrograms.aspx#summerCamps\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"549","%_yoast_wpseo_primary_schools_majors%":"488","%_yoast_wpseo_primary_schools_Region%":"349","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_yoast_wpseo_focuskw%":"Wells School of Music","%_yoast_wpseo_metadesc%":"The Wells School of Music at West Chester University will prepare you to excel as a talented and creative individual.","%_yoast_wpseo_linkdex%":"74","%_thumbnail_id%":"23016","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_oembed_c50b566253bd0ec9d72645a4598a159d%":"<iframe title=\"West Chester University&#039;s Wells School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/WjgsGPYmLr8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_c50b566253bd0ec9d72645a4598a159d%":"1631651347","%_oembed_ea3f4757f30bd768e88214b3b78c5d7a%":"<iframe title=\"Wells School of Music Tour 2021\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/if6BgJan63E?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_ea3f4757f30bd768e88214b3b78c5d7a%":"1631651347","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_5f7bde294ee02cbfc04b8e0bda07f920%":"<iframe title=\"West Chester University&#039;s Wells School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/WjgsGPYmLr8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_5f7bde294ee02cbfc04b8e0bda07f920%":"1701553488","%_oembed_06b8ad07a236ce0355ce0f6adea9bdbc%":"<iframe title=\"Wells School of Music Tour 2021\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/if6BgJan63E?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_06b8ad07a236ce0355ce0f6adea9bdbc%":"1701553488","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Composition &amp; Theory, Conducting, Music Education, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_majors":"Minor in music, Music Education, Music Therapy, Musicology\/ Music History, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":19843,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Concordia University Irvine","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Concordia University Irvine\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2019\/02\/Lead-Photo_1_CSO_2022-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/concordia-university-irvine\/\" class=\"fc-post-link\">Concordia University Irvine<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"33.655011","lng":"-117.809032","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/concordia-university-irvine\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]Music majors at <b>Concordia University Irvine<\/b> study a rigorous core of music classes aimed at developing general musicianship, performance, musical collaboration, critical listening, and an understanding of various contexts of music. Our Music major offers you the opportunity to choose a <b>specialization<\/b> in the following areas:\r\n<ul>\r\n \t<li>Church Music<\/li>\r\n \t<li>Commercial Music<\/li>\r\n \t<li>Composition<\/li>\r\n \t<li>Instrumental Performance<\/li>\r\n \t<li>Music Education<\/li>\r\n \t<li>Piano Performance<\/li>\r\n \t<li>Vocal Performance<\/li>\r\n<\/ul>\r\nEnsembles are open to students studying to be music professionals, as well as students who are non-music majors but desire to perform for the joy of music and sometimes ministry. Some of our most popular <b>ensembles<\/b> include:\r\n<ul>\r\n \t<li>Americana<\/li>\r\n \t<li>Chamber<\/li>\r\n \t<li>Choirs<\/li>\r\n \t<li>Commercial Music<\/li>\r\n \t<li>Handbells<\/li>\r\n \t<li>Jazz<\/li>\r\n \t<li>Orchestras<\/li>\r\n \t<li>Worship<\/li>\r\n<\/ul>\r\nSince 2020, Concordia has <b>partnered with PBS<\/b> to produce and televise our annual Christmas concerts and performances. Our concerts showcase Concordia\u2019s excellent Music Department, from choirs and ensembles to orchestra, commercial music, and more. These made-for-TV productions wouldn\u2019t be possible without top local music venues like the Segerstrom Center for the Arts and Concordia\u2019s exceptional music facilities, including <b>the newest building on campus, the Borland-Manske Center<\/b>.\r\n\r\nThe Borland-Manske Center includes over 50 rooms designed specifically for music-making and teaching, including:\r\n<ul>\r\n \t<li>Charlie and Ling Zhang Orchestra Hall<\/li>\r\n \t<li>Caryn Borland \u201985 Recording Suite<\/li>\r\n \t<li>Henley PIano Studio<\/li>\r\n \t<li>Large choral rehearsal hall<\/li>\r\n \t<li>Teaching studios<\/li>\r\n \t<li>Practice rooms<\/li>\r\n \t<li>Faculty offices<\/li>\r\n \t<li>Ensemble music library<\/li>\r\n \t<li>Student lounges<\/li>\r\n<\/ul>\r\nProspective students who want to perform in Concordia\u2019s music ensembles are strongly encouraged to audition for <b>music scholarships<\/b>. Students accepting Music scholarships enjoy some of the largest financial aid packages that we offer! Exceptional musicians will receive highly competitive offers ranging up to <b>full tuition<\/b> (including academic awards), and students with high school level music competency are very likely to be awarded tuition discounts to encourage participation. Interested students should complete the music scholarship interest form during their final year of high school (or before transferring).[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/-fsCA8ICyNg\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/_JXrTGmtArc\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"24718,24719,24720,24717\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"115\" title=\"true\" description=\"false\" ajax=\"false\"][ultimate_google_map lat=\"33.655011\" lng=\"-117.809032\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Concordia University Irvine","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/concordia-university-irvine\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Concordia University Irvine\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2019\/02\/Lead-Photo_1_CSO_2022-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1680727934:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"33.655011","%_wpgmp_metabox_longitude%":"-117.809032","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"4\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"24715","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"24722","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li><a href=\"https:\/\/www.cui.edu\/arts\/music\/rs\/majoring-music\" target=\"_blank\" rel=\"noopener\">Music School Home Page<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cui.edu\/arts\/music\/academics\/rs\/majoring-music\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cui.edu\/arts\/music\/faculty\/rs\/majoring-music\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cui.edu\/arts\/music\/how-to-apply\/rs\/majoring-music\" target=\"_blank\" rel=\"noopener\">Applications<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cui.edu\/arts\/music\/auditions\/rs\/majoring-music\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cui.edu\/admissions\/undergraduate\/financial-aid\/rs\/majoring-music\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cui.edu\/arts\/music\/scholarships\/rs\/majoring-music\" target=\"_blank\" rel=\"noopener\">Scholarship Opportunities<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cui.edu\/arts\/music\/events\/summer-music\/rs\/majoring-music\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cui.edu\/academicprograms\/undergraduate\/majors\/music\/rs\/majoring-music#Alumni-Success\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_degrees%":"479","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"539","%_yoast_wpseo_primary_schools_Region%":"351","%_oembed_e5c3d1dde789485c22c21e7e545603d0%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/l2r7CmrNUEo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_e5c3d1dde789485c22c21e7e545603d0%":"1549310658","%_oembed_51a5db15fd901680135d738eef886354%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/2K0LLc114Xc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_51a5db15fd901680135d738eef886354%":"1549310658","%_thumbnail_id%":"24721","%_oembed_02f5f50496e979004e0c4de498addd68%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Tsid9nJQeVg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_02f5f50496e979004e0c4de498addd68%":"1549559512","%_oembed_3ca3a2a8e359150d4e2868db0aac4e27%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/67IOSOJmv6k?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_3ca3a2a8e359150d4e2868db0aac4e27%":"1549583083","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_9fe8ee2088774d218b9dd6d8f0a8c484%":"<iframe title=\"Borland-Manske Center Opening Fall 2019 - Music Facility\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Tsid9nJQeVg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_9fe8ee2088774d218b9dd6d8f0a8c484%":"1567725490","%_oembed_2b832db595eeb8186a395512523ea991%":"<iframe title=\"&quot;Merry Christmas, Merry Christmas&quot; from Concordia Christmas 2018\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/67IOSOJmv6k?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_2b832db595eeb8186a395512523ea991%":"1567725491","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_a2f6e3a900ca48bf29f037704ee80f68%":"<iframe title=\"Borland-Manske Center: Music Wing\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/-fsCA8ICyNg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_a2f6e3a900ca48bf29f037704ee80f68%":"1680717643","%_oembed_3b28ce6ebd1935ef03cc6f034831df88%":"<iframe title=\"The Thrill of Hope, A Concordia Christmas 2022\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/_JXrTGmtArc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_3b28ce6ebd1935ef03cc6f034831df88%":"1680717644","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_b55551cb35c4b5f5b33b2b0779b33476%":"<iframe title=\"Borland-Manske Center: Music Wing\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/-fsCA8ICyNg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_b55551cb35c4b5f5b33b2b0779b33476%":"1701543167","%_oembed_e47c460953fb7d3a8ae5fb4b773ab23b%":"<iframe title=\"The Thrill of Hope, A Concordia Christmas 2022\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/_JXrTGmtArc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_e47c460953fb7d3a8ae5fb4b773ab23b%":"1701543167","taxonomy=post_tag":"","taxonomy=schools_degrees":"Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Composition &amp; Theory, Minor in music, Music (B.A.), Music Education, Musical Theatre, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Sacred Music","taxonomy=schools_Region":"Western US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png"},"id":18959,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png","name":"Western US Music Schools","id":"3","type":"category"}]},{"source":"post","title":"Wheaton College Conservatory of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Wheaton Conservatory string quartet\" width=\"600\" height=\"401\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2018\/11\/Wheaton-Conservatory-string-quartet-600x401.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/wheaton-college-conservatory-of-music\/\" class=\"fc-post-link\">Wheaton College Conservatory of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"41.868736","lng":"-88.100672","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/wheaton-college-conservatory-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<div class=\"\">\r\n\r\nThe Wheaton College Conservatory of Music is a rigorous and distinctly Christian professional school with courses leading to the <strong>Bachelor of Music and Bachelor of Music Education<\/strong> degrees, and as a division of Wheaton College, offering courses leading to the <strong>Bachelor of Arts in Music<\/strong> degrees. Our programs will challenge you to grow in your musical ability, knowledge, and creativity while providing the support and encouragement for wholistic personal and spiritual development.\r\n\r\nLocated just 25 miles west of downtown Chicago, you will be able to rub elbows with some of the world\u2019s greatest musicians of our time. Whether it is attending the opera at the Lyric Opera of Chicago as part of a class or listening to the prestigious Chicago Symphony Orchestra in our historic Edman Chapel, you will not be short on connections or inspiration.\r\n\r\n<strong>Fast Facts:<\/strong>\r\n<ul>\r\n \t<li>7:1 music major ratio to faculty<\/li>\r\n \t<li>New Conservatory facilities<\/li>\r\n \t<li>Four performance halls, including a 2,350-seat chapel, a 650-seat concert hall, and a 108-seat recital hall<\/li>\r\n \t<li>55+ music faculty<\/li>\r\n \t<li>Numerous on- and off-campus opportunities<\/li>\r\n \t<li>Workshop Arts Certificate<\/li>\r\n \t<li>Music Merit Awards<\/li>\r\n \t<li>Nine music ensembles\r\n<ul>\r\n \t<li>Concert Choir<\/li>\r\n \t<li>Jazz Ensemble<\/li>\r\n \t<li>Men\u2019s Glee Club<\/li>\r\n \t<li>Opera Mainstage<\/li>\r\n \t<li>Percussion Ensemble<\/li>\r\n \t<li>Symphony Orchestra<\/li>\r\n \t<li>Symphonic Band<\/li>\r\n \t<li>Women\u2019s Chorale<span class=\"Apple-converted-space\">\u00a0<\/span><\/li>\r\n \t<li>Chamber Music Groups<\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>\r\nThe Conservatory of Music is served by experienced music faculty, representing 400 years of teaching and performing, ranging from members of the Lyric Opera and Chicago Symphony Orchestra to notable musicians in churches, schools, business,<span class=\"Apple-converted-space\">\u00a0<\/span>and recording.\r\n\r\n<\/div>\r\n&nbsp;\r\n<div class=\"\"><span class=\"\"><span class=\"\" style=\"font-size: large;\"><em><span style=\"font-size: 14pt;\"><strong>\u201cWheaton provides a customized education where you can build strong friendships with your classmates and professors. They have given me various perspectives on my works, and I\u2018ve been able to develop different musical palates.\u201d<\/strong><\/span><\/em> <span style=\"font-size: 12pt;\">\u2013 Elliot Leung '16, film composer<\/span><\/span><\/span><\/div>\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/vimeo.com\/478318617\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=ECw4MuMv9io\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][vc_gallery type=\"image_grid\" images=\"18531,18532,18534,18533\" img_size=\"600x400\" onclick=\"\"][gravityform id=\"113\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"41.868736\" lng=\"-88.100672\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Wheaton College Conservatory of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/wheaton-college-conservatory-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Wheaton Conservatory string quartet\" width=\"600\" height=\"401\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2018\/11\/Wheaton-Conservatory-string-quartet-600x401.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1728430635:4","%_edit_last%":"4","%_thumbnail_id%":"18530","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"41.868736","%_wpgmp_metabox_longitude%":"-88.100672","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"21949","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"18537","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li><a href=\"https:\/\/www.wheaton.edu\/wheaton-college-conservatory-of-music\/?utm_source=web_ad&amp;utm_medium=web&amp;utm_campaign=con_mim_recruit&amp;utm_content=homepage\" target=\"_blank\" rel=\"noopener\">Music School Home Page<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.wheaton.edu\/wheaton-college-conservatory-of-music\/faculty\/?utm_source=web_ad&amp;utm_medium=web&amp;utm_campaign=con_mim_recruit&amp;utm_content=faculty\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.wheaton.edu\/wheaton-college-conservatory-of-music\/music-degree-programs\/?utm_source=web_ad&amp;utm_medium=web&amp;utm_campaign=con_mim_recruit&amp;utm_content=degrees\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.wheaton.edu\/undergraduate-admissions\/apply-to-wheaton\/apply-to-the-conservatory-of-music\/\" target=\"_blank\" rel=\"noopener\">Applications and Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.wheaton.edu\/admissions-and-aid\/cost-and-financial-aid\/for-prospective-students\/?utm_source=web_ad&amp;utm_medium=web&amp;utm_campaign=con_mim_recruit&amp;utm_content=cost\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.wheaton.edu\/admissions-and-aid\/cost-and-financial-aid\/student-financial-services\/financial-aid-\/academic-scholarships\/?utm_source=web_ad&amp;utm_medium=web&amp;utm_campaign=con_mim_recruit&amp;utm_content=scholarships\" target=\"_blank\" rel=\"noopener\">Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.wheaton.edu\/wheaton-college-conservatory-of-music\/music-events-calendar\/summer-music-camp\/?utm_source=web_ad&amp;utm_medium=web&amp;utm_campaign=con_mim_recruit&amp;utm_content=musiccamp\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_oembed_89c549b7d4bb3ddb545b1f572ebc1503%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/252571875?app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"Wheaton College Conservatory of Music\" allow=\"autoplay; fullscreen\" allowfullscreen><\/iframe>","%_oembed_time_89c549b7d4bb3ddb545b1f572ebc1503%":"1541529038","%_oembed_7acafbd266417a86659584308c3b7f59%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Hoki9Ytp7iU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_7acafbd266417a86659584308c3b7f59%":"1541529038","%_yoast_wpseo_primary_schools_degrees%":"479","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"497","%_yoast_wpseo_primary_schools_Region%":"348","%_yoast_wpseo_focuskw%":"Wheaton College Conservatory of Music","%_yoast_wpseo_title%":"%%title%% %%page%%","%_yoast_wpseo_metadesc%":"The Wheaton College Conservatory of Music is a distinctly Christian school that functions both as a professional school and as a department of the College.","%_yoast_wpseo_linkdex%":"63","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_c3897e228d97a7e53bd73dfa586a757d%":"<iframe title=\"Wheaton College Conservatory of Music\" src=\"https:\/\/player.vimeo.com\/video\/252571875?dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen\" allowfullscreen><\/iframe>","%_oembed_time_c3897e228d97a7e53bd73dfa586a757d%":"1567769596","%_oembed_88b3b76711c6d2fb15860ae2da4f71b4%":"<iframe title=\"Dance of the Tumblers \u2013 Nicolai Rimsky-Korsakov | Wheaton College Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Hoki9Ytp7iU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_88b3b76711c6d2fb15860ae2da4f71b4%":"1567769597","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_aeea113d627ac64c2ef520db9cd21285%":"<iframe title=\"Concerto Grosso, Op.6 No.2 in F major \u2013 George Frideric Handel | Wheaton College Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ECw4MuMv9io?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_aeea113d627ac64c2ef520db9cd21285%":"1605295607","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_oembed_90a5f44abf48ad41b4dee8cbb0d6a587%":"<iframe title=\"About the Armerding Center for Music and the Arts\" src=\"https:\/\/player.vimeo.com\/video\/478318617?h=df5cbc6bf2&amp;dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_90a5f44abf48ad41b4dee8cbb0d6a587%":"1638302702","%_oembed_2b12ab10cce10a9245e2b74f75bd79ff%":"<iframe title=\"About the Armerding Center for Music and the Arts\" src=\"https:\/\/player.vimeo.com\/video\/478318617?h=df5cbc6bf2&amp;dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_2b12ab10cce10a9245e2b74f75bd79ff%":"1638303192","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_93835c6181549eaef5ff5bd074b3fd1c%":"<iframe title=\"About the Armerding Center for Music and the Arts\" src=\"https:\/\/player.vimeo.com\/video\/478318617?dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\"><\/iframe>","%_oembed_time_93835c6181549eaef5ff5bd074b3fd1c%":"1701549908","%_oembed_f8e44242b4704709b02dc871bd625455%":"<iframe title=\"Concerto Grosso, Op.6 No.2 in F major \u2013 George Frideric Handel | Wheaton College Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ECw4MuMv9io?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_f8e44242b4704709b02dc871bd625455%":"1701549908","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"","taxonomy=schools_degrees":"Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Composition &amp; Theory, Music (B.A.), Music Education, Musicology\/ Music History, Pedagogy, Performance - Instrumental","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":18529,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"Butler University School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Butler University School of Music\" width=\"600\" height=\"384\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2018\/10\/Butler-University-Music-More-600x384.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/butler-university-school-of-music\/\" class=\"fc-post-link\">Butler University School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"4600 Sunset Ave, Indianapolis, IN 46208, USA","location":{"lat":"39.84008559999999","lng":"-86.17059269999999","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/butler-university-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p style=\"font-weight: 400;\"><strong><span style=\"font-size: 14pt;\">MORE. This simple word describes the opportunities you\u2019ll have at the Butler University School of Music.<\/span><\/strong><\/p>\r\n<p style=\"font-weight: 400;\">Our flexible curriculum allows you to pursue a double major, study abroad, collaborate with internationally-acclaimed artists, participate in multiple ensembles, complete an internship or major research project, teach in the Butler Community Arts School, and so much more\u2014all with the encouragement of Butler's world-renowned faculty.<\/p>\r\n<p style=\"font-weight: 400;\"><strong><span style=\"font-size: 14pt;\">We offer:<\/span><\/strong><\/p>\r\n\r\n<ul style=\"font-weight: 400;\">\r\n \t<li><strong>Multiple, flexible degree options<\/strong> in Instrumental or Vocal Performance, Jazz Studies, Music Education, and Composition, including over 40 <strong>double majors <\/strong>outside of music!<\/li>\r\n \t<li><strong>Professional collaborations with internationally acclaimed artists<\/strong> through our JCA Signature Series, an artist and scholar residency program, and Butler affiliates like the Indianapolis Chamber Orchestra and Indianapolis Chamber Choir.<\/li>\r\n \t<li><strong>Big city perks with a small-town feel.<\/strong> Our campus is located in a beautiful residential area just five miles north of downtown Indianapolis, a musically and artistically vibrant city.<\/li>\r\n \t<li><strong>Performance opportunities starting your first semester<\/strong> in state-of-the-art, on-campus venues in the Butler Arts and Events Center complex that hosts 250+ artistic performances every year.<\/li>\r\n \t<li>And MORE!<\/li>\r\n<\/ul>\r\n<b>Quick Facts:<\/b>\r\n<ul>\r\n \t<li><b>99%<\/b> of graduates were employed or attending graduate school within one year of graduation<\/li>\r\n \t<li><b>25%<\/b> of music majors pursue a second major or minor in another academic area<\/li>\r\n \t<li><b>100+<\/b> Butler Music majors teach almost 2,000 young people annually at the Butler Community Arts School<\/li>\r\n \t<li><b>300+<\/b> performances held annually at Butler Arts Center<\/li>\r\n \t<li>Our <b>Bachelor of Arts in Music<\/b> degree is one of Butler\u2019s <b>3-year degree options<\/b><\/li>\r\n<\/ul>\r\n<p style=\"font-weight: 400;\">Virtual and in-person visit options are available. Please email <a href=\"mailto:music@butler.edu\">music@butler.edu<\/a> or call 317-940-9567 to connect with us!<\/p>\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/36Z8QZ-2t5E\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/Iy7JYN_EgyE\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"24283,24281,24284,24282\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"112\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"39.84008559999999\" lng=\"-86.17059269999999\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Butler University School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/butler-university-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Butler University School of Music\" width=\"600\" height=\"384\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2018\/10\/Butler-University-Music-More-600x384.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1696908389:9","%_edit_last%":"9","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"4600 Sunset Ave, Indianapolis, IN 46208, USA","%_wpgmp_metabox_latitude%":"39.84008559999999","%_wpgmp_metabox_longitude%":"-86.17059269999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"90","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"18372","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"25217","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li><a href=\"http:\/\/www.butler.edu\/music\" target=\"_blank\" rel=\"noopener\">Music School Home Page<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.butler.edu\/jordan-arts\/undergraduate-programs\/music\/faculty-staff\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.butler.edu\/jordan-arts\/undergraduate-programs\/music\/majors-minors\/\" target=\"_blank\" rel=\"noopener\">Majors\/Minors<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.butler.edu\/academics\/three-year-programs\/music\/\" target=\"_blank\" rel=\"noopener\">BA Music 3-Year Degree<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.butler.edu\/jordan-arts\/undergraduate-programs\/music\/apply\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Applications\/Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.butler.edu\/jordan-arts\/undergraduate-programs\/music\/graduate-studies\/\" target=\"_blank\" rel=\"noopener\">Graduate Programs &amp; Applications<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.butler.edu\/admission-aid\/tuition-costs\/\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.butler.edu\/admission-aid\/financial-aid-scholarships\/first-year\/\" target=\"_blank\" rel=\"noopener\">Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.butler.edu\/jordan-arts\/butler-community-arts-school\/summer-camps\/\" target=\"_blank\" rel=\"noopener\">Summer Programs<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"555","%_yoast_wpseo_primary_schools_majors%":"497","%_yoast_wpseo_primary_schools_Region%":"348","%_oembed_ff5bfaf5a96d56cb9aa25c5c9e1a4523%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Qoblqi3cc_4?start=2294&feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_ff5bfaf5a96d56cb9aa25c5c9e1a4523%":"1539117519","%_oembed_e09b7b680ac5d1bdeaf729cf0ed19213%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/6Id8FEN8q0g?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_e09b7b680ac5d1bdeaf729cf0ed19213%":"1539117519","%_thumbnail_id%":"24279","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_715496f700bd6facef67557d3e468f63%":"<iframe title=\"Butler - School of Music Wind Ensemble Performance | Butler University\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Qoblqi3cc_4?start=2294&feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_715496f700bd6facef67557d3e468f63%":"1567741474","%_oembed_7299151cd1f20f5031f53486640a0bf1%":"<iframe title=\"JCA Recruitment Updated Video 004\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/6Id8FEN8q0g?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_7299151cd1f20f5031f53486640a0bf1%":"1567741474","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_6e4dbe4584861ce82ebc75ce56a09ef5%":"<iframe title=\"Butler Virtual Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/cysteFKIjrw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_6e4dbe4584861ce82ebc75ce56a09ef5%":"1603224751","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_2fc306e39630c8e858509b204e877b25%":"<iframe title=\"Meet Megan- Music Ed and Performance double major!\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/36Z8QZ-2t5E?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_2fc306e39630c8e858509b204e877b25%":"1666119099","%_oembed_82cf9ec3248c78d3c5141a8b64569494%":"<iframe title=\"Meet David, Jazz Studies Major, Class of 2022!\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Iy7JYN_EgyE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_82cf9ec3248c78d3c5141a8b64569494%":"1666119099","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_a3b60c2e459514c6fe8be34fb66bebab%":"<iframe title=\"Meet Megan- Music Ed and Performance double major!\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/36Z8QZ-2t5E?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_a3b60c2e459514c6fe8be34fb66bebab%":"1701543011","%_oembed_505ab36ef2957bed4b39e995599b9ec0%":"<iframe title=\"Meet David, Jazz Studies Major, Class of 2022!\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Iy7JYN_EgyE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_505ab36ef2957bed4b39e995599b9ec0%":"1701543011","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Composition &amp; Theory, Music Education, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_majors":"Arts Management, Composition &amp; Theory, Minor in music, Music (B.A.), Music Education, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":18342,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"Manhattan School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Manhattan School of Music campus\" width=\"600\" height=\"450\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2018\/09\/Manhattan-School-of-Music-campus-600x450.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/manhattan-school-of-music\/\" class=\"fc-post-link\">Manhattan School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"40.812482","lng":"-73.961363","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/manhattan-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]Manhattan School of Music prepares highly talented students from around the world for careers as passionate performers and composers. Our students thrive in a supportive atmosphere that encourages excellence, values individuals, and welcomes innovation. We are proud to shape imaginative, effective leaders in the arts.\r\n\r\nSituated in Morningside Heights on Manhattan\u2019s West Side, MSM\u2019s closed campus boasts 22 classrooms, 130 practice rooms, 8 performance spaces, 2 recording studios and a 450 bed residence hall. MSM offers <b>700 performances per year<\/b>, including fully-staged operas, orchestral concerts, student and faculty recitals, jazz concerts, and more than <b>100 master classes a year<\/b>.\r\n\r\nMSM\u2019s location gives students the opportunity throughout the year not only to hear, but also to perform, music in some of the greatest venues in the world. In recent years, MSM student ensembles have performed at Carnegie Hall, Lincoln Center, Jazz at Lincoln Center, Birdland, National Sawdust, the Apollo, and the Cathedral of St. John the Divine.\r\n\r\nManhattan School of Music\u2019s <b>faculty is made up of members of New York City\u2019s leading performing institutions<\/b>\u2013the New York Philharmonic, Metropolitan Opera, New York City Opera, Chamber Music Society of Lincoln Center, Lincoln Center Jazz Orchestra, and the Orpheus Chamber Orchestra\u2013as well as acclaimed soloists, chamber musicians, and jazz artists.\r\n\r\nMSM offers <b>Study Abroad<\/b> options at numerous conservatories in Europe, Asia, and Australia for both undergraduate and graduate students. MSM\u2019s <b>Center for Music Entrepreneurship (CME)<\/b> gives students the entrepreneurial skills and practical experience they need to succeed in the professional world.\r\n\r\nStudents can take their MSM education beyond the campus. The <b>Orto Center<\/b> connects MSM with peer institutions through live videoconference master classes where students can learn from renowned faculty and artists and engage with fellow student musicians around the world. MSM also provides students with opportunities to take part in community engagement programs and arts-in-education programs to prepare them to become effective artist educators.\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/OeQD8egWdJg\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/SzX6Tr08h18\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][vc_gallery type=\"image_grid\" images=\"18242,21936,21937,21938\" img_size=\"600x400\" onclick=\"\"][gravityform id=\"110\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"40.812482\" lng=\"-73.961363\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Manhattan School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/manhattan-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Manhattan School of Music campus\" width=\"600\" height=\"450\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2018\/09\/Manhattan-School-of-Music-campus-600x450.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"","%easyindexInvalidate%":"1","%_edit_lock%":"1691454035:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"40.812482","%_wpgmp_metabox_longitude%":"-73.961363","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"21943","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"21935","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li><a href=\"http:\/\/www.msmnyc.edu\" target=\"_blank\" rel=\"noopener\">Music School Home Page<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.msmnyc.edu\/faculty\/?programs=college\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.msmnyc.edu\/programs\/\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.msmnyc.edu\/admission\/apply-to-msm\/\" target=\"_blank\" rel=\"noopener\">Application<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.msmnyc.edu\/admissions\/general-audition-information\/\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.msmnyc.edu\/admissions\/tuition-overview\/\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.msmnyc.edu\/admissions\/scholarships-financial-aid\/\" target=\"_blank\" rel=\"noopener\">Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.msmnyc.edu\/admissions\/graduate-studies\/\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.msmnyc.edu\/success-stories\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_degrees%":"479","%_yoast_wpseo_primary_schools_graduateschools_majors%":"564","%_yoast_wpseo_primary_schools_majors%":"483","%_yoast_wpseo_primary_schools_Region%":"349","%_yoast_wpseo_focuskw%":"Manhattan School of Music","%_yoast_wpseo_title%":"%%title%%","%_yoast_wpseo_metadesc%":"Manhattan School of Music prepares highly talented students for careers as passionate performers and composers and effective leaders in the arts.","%_yoast_wpseo_linkdex%":"72","%_oembed_13434013040a2def63fd44da296508e9%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/OeQD8egWdJg?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_13434013040a2def63fd44da296508e9%":"1536782097","%_oembed_02c06797e4fcd9edc6de97c30574093e%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/0f3wU4OVVpw?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_02c06797e4fcd9edc6de97c30574093e%":"1536782097","%_thumbnail_id%":"21934","%_oembed_39663b48d273726d273d7f5a632a9bf1%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/OeQD8egWdJg?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_39663b48d273726d273d7f5a632a9bf1%":"1536782651","%_wp_old_date%":"2018-09-12","%_oembed_55b1b76b280cbb40e992f4ad435535b7%":"<iframe title=\"The MSM Neighborhood\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/OeQD8egWdJg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_55b1b76b280cbb40e992f4ad435535b7%":"1567723529","%_oembed_6e6868edf80c2ecfc74f21fc666df97c%":"<iframe title=\"MSM Opera Theater presents Rossini&#039;s La Cenerentola\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/0f3wU4OVVpw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_6e6868edf80c2ecfc74f21fc666df97c%":"1567723529","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_38b760b9cde2d19a2c6d0d1600236512%":"<iframe title=\"MSM Philharmonia, conducted by George Manahan\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/SzX6Tr08h18?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_38b760b9cde2d19a2c6d0d1600236512%":"1605292938","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_4b4873ae6629a0cea25f501b20908be1%":"<iframe title=\"The MSM Neighborhood\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/OeQD8egWdJg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_4b4873ae6629a0cea25f501b20908be1%":"1701544383","%_oembed_90b2f6332c6f2b088e2e7a8b0a72b8b9%":"<iframe title=\"MSM Philharmonia, conducted by George Manahan\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/SzX6Tr08h18?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_90b2f6332c6f2b088e2e7a8b0a72b8b9%":"1701544383","taxonomy=post_tag":"","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Conducting, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Musical Theatre, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":18239,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Boston University School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Boston University School of Music\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2018\/07\/Boston-University-School-of-Music-Musical-Theatre.jpg-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/boston-university-school-of-music\/\" class=\"fc-post-link\">Boston University School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"42.351477","lng":"-71.113874","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/boston-university-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\"><strong>Boston University School of Music<\/strong> offers the best of both worlds: a conservatory-style music program and the diverse opportunities of a major research university.<\/p>\r\nThe School of Music is a community of academically and artistically extraordinary musicians located in one of the great music capitals of America. Studying under internationally recognized faculty-artists, BU students push the limits of their musical abilities and intellectual curiosity. Join a vibrant community in a city where music matters, and be transformed not only as an artist but as a leader, entrepreneur, advocate, and thinker.\r\n\r\nMore than 50 BU School of Music graduates currently play with major symphonies across the country, including the Boston Symphony Orchestra, New York Philharmonic, Chicago Symphony Orchestra, and Los Angeles Philharmonic. Our alumni include nominees and winners of Tonys, Grammys, Golden Globes, Oscars, Emmys, and Screen Actor Guild Awards. They are teachers, community leaders, scholars, lawyers, designers, and business executives. In short, our graduates are represented in all of walks of life. What they all share is the BU experience: a foundation of tangible and meaningful professional skills.\r\n\r\n\u201cMy time at CFA prepared me for a career as a freelance composer, an opera composer, a film composer, a curator and a professor. BU gives you a strong education in the fundamentals, but also encourages you to develop your own artistic identity. You can go anywhere from here!\u201d\r\n- Missy Mazzoli (BM \u201802, BUTI \u201898)\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n<div class=\"schools-social-wrapper\">\r\n<div class=\"schools-social facebook-social\">[acf field='facebook-social']<\/div>\r\n<div class=\"schools-social twitter-social\">[acf field='twitter-social']<\/div>\r\n<div class=\"schools-social instagram-social\">[acf field='instagram-social']<\/div>\r\n<div class=\"schools-social youtube-social\">[acf field='youtube-social']<\/div>\r\n<\/div>\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=BL_dFAUSwwI&amp;feature=youtu.be\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=971Eho12gX8&amp;t=23s\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"17770,17769,17771,17772\" img_size=\"300x200\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"105\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"42.351477\" lng=\"-71.113874\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Boston University School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/boston-university-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Boston University School of Music\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2018\/07\/Boston-University-School-of-Music-Musical-Theatre.jpg-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Boston University, Boston University School of Music, College of Music, major in music, majoring in music, Music colleges, music degree, music education, music major, music school, music students, School of Music","%easyindexInvalidate%":"1","%_edit_lock%":"1696892987:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.351477","%_wpgmp_metabox_longitude%":"-71.113874","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"90","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"17767","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"17765","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li><a href=\"http:\/\/www.bu.edu\/cfa\/music\/\" target=\"_blank\" rel=\"noopener\">Music Home Page<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.bu.edu\/cfa\/academics\/degrees-programs\/?dicipline=music&amp;bu_progs_education-level=undergraduate\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.bu.edu\/cfa\/academics\/faculty-staff\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.bu.edu\/cfa\/music\/admissions-auditions\/undergraduate-admissions\/\" target=\"_blank\" rel=\"noopener\">Applications and Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.bu.edu\/cfa\/music\/admissions-auditions\/graduate-admissions\/\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.bu.edu\/admissions\/apply\/tuition-aid-scholarships\/\" target=\"_blank\" rel=\"noopener\">Tuition and Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.bu.edu\/mysummer\/arts\/tanglewood-institute\/\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"548","%_yoast_wpseo_primary_schools_majors%":"497","%_yoast_wpseo_primary_schools_Region%":"349","%_oembed_436ae9f024087f89cce37dffe02b3a69%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/BL_dFAUSwwI?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_436ae9f024087f89cce37dffe02b3a69%":"1531172511","%_oembed_4e34a513e6bd94cc3cb34cfa433f3613%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/GG4qo8BivP4?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_4e34a513e6bd94cc3cb34cfa433f3613%":"1531172512","%_thumbnail_id%":"17774","%_yoast_wpseo_focuskw_text_input%":"Boston University School of Music","%_yoast_wpseo_focuskw%":"Boston University School of Music","%_yoast_wpseo_metadesc%":"Boston University School of Music offers the best of both worlds: a conservatory-style music program and the opportunities of a major research university.","%_yoast_wpseo_linkdex%":"69","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_089cb9db5ae93238c4bc80d0167b8f79%":"{{unknown}}","%facebook-social%":"<a href=\"https:\/\/www.facebook.com\/BU.SchoolofMusic\/\" rel=\"noopener\" target=\"_blank\">https:\/\/www.facebook.com\/BU.SchoolofMusic\/<\/a>","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"<a href=\"https:\/\/twitter.com\/bu_som?lang=en\" rel=\"noopener\" target=\"_blank\">https:\/\/twitter.com\/bu_som?lang=en<\/a>","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"<a href=\"https:\/\/www.instagram.com\/bu_music\/?hl=en\" rel=\"noopener\" target=\"_blank\">https:\/\/www.instagram.com\/bu_music\/?hl=en<\/a>","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"<a href=\"https:\/\/www.youtube.com\/channel\/UCBiMT6bXnGsWfFzAhkJ_kxQ\" rel=\"noopener\" target=\"_blank\">https:\/\/www.youtube.com\/channel\/UCBiMT6bXnGsWfFzAhkJ_kxQ<\/a>","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_e854ecafb7dc37c46088f310fccc86c1%":"<iframe title=\"David Martins on Passion and Music Making\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/971Eho12gX8?start=23&feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_e854ecafb7dc37c46088f310fccc86c1%":"1562539891","%_oembed_9e7c8a78b76f48c76ad1ed50a68667bf%":"<iframe title=\"We are BU College of Fine Arts.\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/BL_dFAUSwwI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_9e7c8a78b76f48c76ad1ed50a68667bf%":"1567720591","%_oembed_529eefadc48a210f52c898ef3607c696%":"<iframe title=\"David Martins on Passion and Music Making\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/971Eho12gX8?start=23&feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_529eefadc48a210f52c898ef3607c696%":"1567720591","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_71c43385eb14e93ea82c754802367db5%":"<iframe title=\"We are BU College of Fine Arts.\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/BL_dFAUSwwI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_71c43385eb14e93ea82c754802367db5%":"1701542671","%_oembed_22d249a1a8b453dc5c519003820fef73%":"<iframe title=\"David Martins on Passion and Music Making\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/971Eho12gX8?start=23&feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_22d249a1a8b453dc5c519003820fef73%":"1701542671","taxonomy=post_tag":"Boston University, Boston University School of Music, College of Music, major in music, majoring in music, Music colleges, music degree, music education, music major, music school, music students, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Conducting, Early Music\/ Historical Performance, Ethnomusicology, Music Education, Musicology, Opera - Directing, Performance - Instrumental, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Ethnomusicology, Minor in music, Music (B.A.), Music Education, Musicology\/ Music History, Performance - Instrumental, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":17759,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Arizona State University School of Music, Dance and Theatre","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Arizona State University School of Music, Dance and Theatre\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2018\/06\/asunew-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/arizona-state-university-school-of-music\/\" class=\"fc-post-link\">Arizona State University School of Music, Dance and Theatre<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"33.4182251","lng":"-111.93873300000001","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/arizona-state-university-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\"><strong>Arizona State University offers you a cutting-edge music program with an abundance of opportunities to inspire creativity. Our nationally and internationally recognized faculty artists, scholars and guest artists work with students to cultivate excellence and personal growth.<\/strong><\/p>\r\nWe attract scores of talented musicians from nearly every state and many countries abroad who bring a thirst for music, high performing standards and a drive for excellence that helps create an environment where you can excel and at the same time pursue your own individual passion and course of study.\r\n\r\nLocated in the culturally rich Southwest desert in one of the country\u2019s most vibrant, expanding urban centers, the ASU School of Music, Dance and Theatre affords its students not only access to this diverse environment but also engagement in Phoenix\u2019s diverse, flourishing arts community.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\n<strong>You can truly achieve anything you want here and be a part of a major research university that also nurtures, values and inspires creativity, innovation and excellence.<\/strong>\r\n<ul>\r\n \t<li>Building upon rich traditional foundations<\/li>\r\n \t<li>Advancing innovative musical practices<\/li>\r\n \t<li>Promoting all forms of creative contributions to the field of music<\/li>\r\n \t<li>Motivating and compassionate faculty mentors<\/li>\r\n \t<li>Innovative and collaborative programs of study<\/li>\r\n \t<li>Pursue 39 graduate and undergraduate degrees including <strong>Popular Music<\/strong>, 3 minors, 5 certificates<\/li>\r\n \t<li>Over 650 concerts and recitals offered on campus<\/li>\r\n \t<li>Extensive partnerships with Phoenix metropolitan arts organizations<\/li>\r\n \t<li>A place to pursue your passion at every level<\/li>\r\n<\/ul>\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/vimeo.com\/119561040\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/vimeo.com\/119560756\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"23938,17702,17704,23937\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"146\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"33.4182251\" lng=\"-111.93873300000001\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Arizona State University School of Music, Dance and Theatre","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/arizona-state-university-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Arizona State University School of Music, Dance and Theatre\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2018\/06\/asunew-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Arizona State University School of Music, College of Music, major in music, majoring in music, Music colleges, music degree, music education, music major, music school, music students, School of Music","%easyindexInvalidate%":"1","%_edit_lock%":"1721095287:9","%_edit_last%":"9","%_thumbnail_id%":"25889","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"33.4182251","%_wpgmp_metabox_longitude%":"-111.93873300000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"4\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Arizona State University","%_yoast_wpseo_focuskw%":"Arizona State University","%_yoast_wpseo_title%":"Arizona State University School of Music, Dance and Theatre","%_yoast_wpseo_metadesc%":"As one of the top music schools in the nation, the School of Music at Arizona State University is committed to inspiring and empowering our students","%_yoast_wpseo_linkdex%":"63","%_yoast_wpseo_content_score%":"90","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"22452","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"17706","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<a href=\"https:\/\/musicdancetheatre.asu.edu\/\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a>\r\n\r\n<a href=\"https:\/\/musicdancetheatre.asu.edu\/degree-programs\/undergraduate\" target=\"_blank\" rel=\"noopener\">Undergraduate Degrees<\/a>\r\n\r\n<a href=\"https:\/\/musicdancetheatre.asu.edu\/degree-programs\/graduate\" target=\"_blank\" rel=\"noopener\">Graduate Degree Programs<\/a>\r\n\r\n<a href=\"https:\/\/musicdancetheatre.asu.edu\/people\/faculty?dept=392823&amp;id=1\" target=\"_blank\" rel=\"noopener\">Faculty<\/a>\r\n\r\n<a href=\"https:\/\/musicdancetheatre.asu.edu\/admission\/apply-music-major\" target=\"_blank\" rel=\"noopener\">Undergraduate Applications &amp; Auditions<\/a>\r\n\r\n<a href=\"https:\/\/musicdancetheatre.asu.edu\/admission\/graduate-music-admission\" target=\"_blank\" rel=\"noopener\">Graduate Applications &amp; Auditions<\/a>\r\n\r\n<a href=\"https:\/\/students.asu.edu\/standard-cost-attendance\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a>\r\n\r\n<a href=\"https:\/\/musicdancetheatre.asu.edu\/admissions\/tuition-and-paying-college\" target=\"_blank\" rel=\"noopener\">Scholarships &amp; Financial Aid<\/a>\r\n\r\n<a href=\"https:\/\/musicdancetheatre.asu.edu\/music-dance-theatre-summer-institute\" target=\"_blank\" rel=\"noopener\">Summer Programs<\/a>\r\n\r\n<a href=\"https:\/\/musicdancetheatre.asu.edu\/admission\/frequently-asked-questions\" target=\"_blank\" rel=\"noopener\">FAQ<\/a>\r\n\r\n<a href=\"https:\/\/herbergerinstitute.asu.edu\/resources\/current-students\/careers?dept=1400&amp;id=1\" target=\"_blank\" rel=\"noopener\">Music Career Resources<\/a>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_degrees%":"479","%_yoast_wpseo_primary_schools_graduateschools_majors%":"561","%_yoast_wpseo_primary_schools_majors%":"491","%_yoast_wpseo_primary_schools_Region%":"351","%_oembed_10eb37c036e4a41b9a76e0f1dab24d67%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/119561040?app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"ASU School of Music - The Student Experience\" webkitallowfullscreen mozallowfullscreen allowfullscreen><\/iframe>","%_oembed_time_10eb37c036e4a41b9a76e0f1dab24d67%":"1529356771","%_oembed_4440ee94438dfd7c7eda965aa98e51c9%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/119560756?app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"School of Music Ensembles - Majors\" webkitallowfullscreen mozallowfullscreen allowfullscreen><\/iframe>","%_oembed_time_4440ee94438dfd7c7eda965aa98e51c9%":"1529356771","%_oembed_9c378c7e0fb5101578d2f0c0596c42de%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/119560756?app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"School of Music Ensembles - Majors\" webkitallowfullscreen mozallowfullscreen allowfullscreen><\/iframe>","%_oembed_time_9c378c7e0fb5101578d2f0c0596c42de%":"1529357984","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_c69de0f9217551982963bddbe0a06ad0%":"<iframe title=\"ASU School of Music - The Student Experience\" src=\"https:\/\/player.vimeo.com\/video\/119561040?dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen\" allowfullscreen><\/iframe>","%_oembed_time_c69de0f9217551982963bddbe0a06ad0%":"1567729380","%_oembed_8a32e47d8d5cd3c61e98d5d5e6543f2c%":"<iframe title=\"School of Music Ensembles - Majors\" src=\"https:\/\/player.vimeo.com\/video\/119560756?dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen\" allowfullscreen><\/iframe>","%_oembed_time_8a32e47d8d5cd3c61e98d5d5e6543f2c%":"1567729380","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_b12070b87e9e0964e84282e85539c08a%":"<iframe title=\"Music Ensembles - Majors\" src=\"https:\/\/player.vimeo.com\/video\/119560756?dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_b12070b87e9e0964e84282e85539c08a%":"1618592693","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_a4d1ffec6061879867e2b144e2b23cc3%":"<iframe title=\"ASU School of Music - The Student Experience\" src=\"https:\/\/player.vimeo.com\/video\/119561040?dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\"><\/iframe>","%_oembed_time_a4d1ffec6061879867e2b144e2b23cc3%":"1701547764","%_oembed_cbfb7f3ed00ba4fb139c66225a42602a%":"<iframe title=\"Music Ensembles - Majors\" src=\"https:\/\/player.vimeo.com\/video\/119560756?dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\"><\/iframe>","%_oembed_time_cbfb7f3ed00ba4fb139c66225a42602a%":"1701547764","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"Arizona State University School of Music, College of Music, major in music, majoring in music, Music colleges, music degree, music education, music major, music school, music students, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Ethnomusicology, Music Education, Music Therapy, Musical Theatre, Musicology, Opera - Directing, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_majors":"Collaborative Piano, Composition &amp; Theory, Music (B.A.), Music Education, Music Therapy, Musical Theatre, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_Region":"Western US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png"},"id":17698,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png","name":"Western US Music Schools","id":"3","type":"category"}]},{"source":"post","title":"Berklee College of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berklee College of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/11\/Berklee-College-of-Music-lead-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/berklee-college-of-music\/\" class=\"fc-post-link\">Berklee College of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"42.34660","lng":"-71.08953","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/berklee-college-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<strong>Berklee College of Music is the world\u2019s premier learning lab for the music of today and tomorrow. Our curriculum is designed to nurture your creative goals with 15 undergraduate majors and two degree types covering performance, composition and production, music business, music education, and more. <\/strong>\r\n\r\n<b>ARTISTIC COLLABORATION<\/b>\r\n\r\nBerklee is a hub for collaborative artistry and innovation. Whether performing, producing, or writing, you will find yourself amidst a community of talented peers who will inspire your creativity and transform your artistry.\r\n\r\n<b>INSPIRED MENTORSHIP<\/b>\r\n\r\nYou\u2019ll learn alongside faculty and artists who continually reshape the music industry. They are active producers, songwriters, performers, entrepreneurs, and engineers who are dedicated to cultivating the next generation of industry leaders.\r\n\r\n<b>CUTTING-EDGE FACILITIES<\/b>\r\n\r\nWith access to state-of-the-art equipment, you\u2019ll gain professional experience that will propel you towards a successful career. Perform, create, and experience music in our studios and world-class performance venues in Boston, MA, including:\r\n\r\n\u25cf \u00a01,215-seat Berklee Performance Center and other on-campus performance venues\r\n\u25cf \u00a0Professional-level production suites and practice rooms\r\n\u25cf \u00a0Fully equipped recording studios\r\n\u25cf \u00a0State-of-the-art film scoring labs\r\n\u25cf \u00a0Creative Technology Labs featuring virtual, augmented, and mixed reality, 360\u00b0\u00a0video, and other immersive media\r\n\r\nPrepare for your future while surrounding yourself by talented musicians and innovators who are\u00a0ready to make their mark, just like you. Apply today at <a href=\"https:\/\/berkleecollege.force.com\/onlineapplication\/TX_CommunitiesSelfReg\" target=\"_blank\" rel=\"noopener\">berklee.edu\/apply<\/a>.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=5sjHG1op8fQ&amp;feature=?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/6APw_nFvZ-A\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_column_inner width=\"1\/2\"][\/vc_column_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"26523,26526,26525,26524\" img_size=\"600x400\" onclick=\"\" css=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"101\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"42.34660\" lng=\"-71.08953\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Berklee College of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/berklee-college-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Berklee College of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/11\/Berklee-College-of-Music-lead-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Berklee College of Music, College of Music, major in music, majoring in music, Music colleges, music degree, music degrees, music education, music industry, music major, music school, music students, School of Music","%easyindexInvalidate%":"1","%_edit_lock%":"1734644955:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.34660","%_wpgmp_metabox_longitude%":"-71.08953","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"16739","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"26522","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/college.berklee.edu\/?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.berklee.edu\/majors?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">Majors<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.berklee.edu\/admissions\/undergraduate\/offcampusevents?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">Events for Prospective Students<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.berklee.edu\/admissions\/undergraduate\/how-to-apply?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\">How to Apply<\/a><\/li>\r\n \t<li><a href=\"https:\/\/college.berklee.edu\/admissions\/undergraduate\/international?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">International Applicants<\/a><\/li>\r\n \t<li><a href=\"https:\/\/college.berklee.edu\/admissions\/undergraduate\/visiting?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">Campus Tours<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.berklee.edu\/bursar\/tuition-and-related-costs?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">Tuition and Fees<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.berklee.edu\/scholarships?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">Scholarships and Financial Aid<\/a><\/li>\r\n \t<li><a href=\"https:\/\/college.berklee.edu\/admissions\/undergraduate\/auditionandinterview?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">Audition and Interview Specifics<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.berklee.edu\/faculty?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.berklee.edu\/alumni\/alumni-news?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">Alumni\u00a0Success Stories<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.berklee.edu\/career-center?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">Career Advising<\/a><\/li>\r\n \t<li><a href=\"https:\/\/cloud.info.berklee.edu\/summer-programs?campaign_id=7010Z000001ZllbQAC&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bsp-su-partner-gif-ad\" target=\"_blank\" rel=\"noopener\">Summer Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.berklee.edu\/graduate?utm_source=majoringinmusic&amp;utm_medium=partner&amp;utm_campaign=bcm-ug-partner-majoringinmusic-site\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_majors%":"489","%_yoast_wpseo_primary_schools_Region%":"349","%_thumbnail_id%":"26521","%_yoast_wpseo_focuskw_text_input%":"Berklee College of Music","%_yoast_wpseo_focuskw%":"Berklee College of Music","%_yoast_wpseo_title%":"Berklee College of Music","%_yoast_wpseo_metadesc%":"With students from over 100 countries, Berklee College of Music is the world's premier learning lab for the music of today\u2014and tomorrow.","%_yoast_wpseo_linkdex%":"67","%_oembed_3ccf510744efed74c1844cdde80133d9%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/XQnxCWq0MTc?feature=oembed\" frameborder=\"0\" gesture=\"media\" allow=\"encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_3ccf510744efed74c1844cdde80133d9%":"1511922357","%_oembed_cd331751e435ea4ff5a2bde87ea79169%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/q3cpOrB1GW8?feature=oembed\" frameborder=\"0\" gesture=\"media\" allow=\"encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_cd331751e435ea4ff5a2bde87ea79169%":"1511922358","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_oembed_8a6bbc2dfb26ffc28b9f7e85bea16867%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/5sjHG1op8fQ?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_8a6bbc2dfb26ffc28b9f7e85bea16867%":"1556900057","%_oembed_a18f4cf561ccdfa5cdc6f343fe0d14b0%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/51589652?dnt=1&app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"Timelapse - Lighthouse (Oct 2012)\" allow=\"autoplay; fullscreen\" allowfullscreen><\/iframe>","%_oembed_time_a18f4cf561ccdfa5cdc6f343fe0d14b0%":"1556900072","%_oembed_ca358fe51058ca718e95822a0a32f4ee%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/5sjHG1op8fQ?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_ca358fe51058ca718e95822a0a32f4ee%":"1557171585","%_oembed_664dc57754edcbca56c4c2e93c799a63%":"<iframe title=\"Exploring Campus - Berklee College of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/5sjHG1op8fQ?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_664dc57754edcbca56c4c2e93c799a63%":"1567728314","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_5ad32cbc59a380c85bbeb92018d37469%":"<iframe title=\"Exploring Campus - Berklee College of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/5sjHG1op8fQ?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_5ad32cbc59a380c85bbeb92018d37469%":"1701541041","%_monsterinsights_sitenote_active%":"0","%_oembed_cc363f55c4083eded19364da6b00f412%":"<iframe title=\"Berklee College of Music | Audition and Interview Process\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/c1kp9i7cr00?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_cc363f55c4083eded19364da6b00f412%":"1701725587","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_wpb_post_custom_layout%":"default","%_oembed_e543b7b810dc3a8e1d098b04c96e90b9%":"<iframe title=\"How to Apply to Berklee College of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/6APw_nFvZ-A?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_e543b7b810dc3a8e1d098b04c96e90b9%":"1734548747","taxonomy=post_tag":"Berklee College of Music, College of Music, major in music, majoring in music, Music colleges, music degree, music degrees, music education, music industry, music major, music school, music students, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Music Business, Music Therapy, Performance - Jazz Instrumental, Recording\/Production\/Engineering, Scoring","taxonomy=schools_majors":"Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Composition &amp; Theory, Music Business, Music Education, Music Industry, Music Technology, Music Therapy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/ Production\/ Engineering, Scoring","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":16736,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Duquesne University, <\/br>Mary Pappert School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Duquesne University, &lt;\/br&gt;Mary Pappert School of Music\" width=\"600\" height=\"261\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/09\/Duquesne-lead-600x261.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/duquesne-university-mary-pappert-school-of-music\/\" class=\"fc-post-link\">Duquesne University, <\/br>Mary Pappert School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"40.437295","lng":"-79.990173","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/duquesne-university-mary-pappert-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<span style=\"font-size: 18pt;\"><b>A Competitive Edge for a Creative Field<\/b><\/span>\r\n\r\n<b>At the Mary Pappert School of Music, you are challenged to connect historical practices with modern methods, blend the traditional with current technology, and explore your artistry, creativity, and ingenuity to the fullest extent.<\/b>\r\n\r\n<b>Distinguishing Features<\/b>\r\n\r\n<strong>Majors offered:<\/strong> Music Education, Performance, Music Technology, Music Therapy, Composition, Jazz, Music Ministry\r\n<ul>\r\n \t<li>GRAMMY Award-winning faculty<\/li>\r\n \t<li>4:1 Student-to-teacher ratio<\/li>\r\n \t<li>Dual Degree, Progressive and Accelerated Pathways options<\/li>\r\n \t<li>Internships, student teaching, job placement and career development support<\/li>\r\n \t<li>All-Steinway Music School, NASM Accredited<\/li>\r\n \t<li>Park-like campus in the heart of downtown Pittsburgh, PA<\/li>\r\n<\/ul>\r\n<b>What\u2019s New<\/b>\r\n<ul>\r\n \t<li>Transfer students who are Pennsylvania residents can receive double the financial aid offered through the PA State Grant Program.<\/li>\r\n \t<li>Master\u2019s degree in Music Therapy now available online.<\/li>\r\n \t<li>BA in Music now available in 3 years. Add a 2-year MBA program!<\/li>\r\n \t<li>The Institute of Entertainment, Music, and Media Arts (IEMMA) provides resources for all students to learn aspects of the commercial music industry.<\/li>\r\n<\/ul>\r\n<b>Our School Promise:<\/b>\r\n\r\nAt the Mary Pappert School of Music, we are building a better future. We invest in each individual student. We value and support the creation of art, exploration of artistic ideas, the preservation of our rich musical past, and the artistic innovation that propels us forward. We pursue music with passion and we challenge our students to explore new ideas, musically, artistically, and intellectually. We demonstrate respect for each other and we demonstrate excellence, integrity, and responsibility in our work as artists, creators, scholars, healers and teachers.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/gLwjbDOra6Q\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/IE9BrdK6dPU\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"20508,24833,20511,24834\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"26\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"40.437295\" lng=\"-79.990173\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Duquesne University, <\/br>Mary Pappert School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/duquesne-university-mary-pappert-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Duquesne University, &lt;\/br&gt;Mary Pappert School of Music\" width=\"600\" height=\"261\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/09\/Duquesne-lead-600x261.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, Duquesne University, major in music, majoring in music, Mary Pappert School of Music, Mary Pappert School of Music at Duquesne University, Music colleges, music degree, music degrees, music education, music major, music school, music therapy, School of Music","%easyindexInvalidate%":"1","%_edit_lock%":"1683307610:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"40.437295","%_wpgmp_metabox_longitude%":"-79.990173","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"19056","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"19062","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Mary Pappert School of Music at Duquesne University\" href=\"https:\/\/duq.edu\/music\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a title=\"Mary Pappert School of Music at Duquesne University\" href=\"https:\/\/www.duq.edu\/academics\/colleges-and-schools\/music\/music-admissions\/programs.php\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a title=\"Mary Pappert School of Music at Duquesne University\" href=\"https:\/\/duq.edu\/musicfaculty\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Mary Pappert School of Music at Duquesne University\" href=\"https:\/\/www.duq.edu\/academics\/colleges-and-schools\/music\/music-admissions\/index.php\" target=\"_blank\" rel=\"noopener\">Apply and Audition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.duq.edu\/admission-and-aid\/tuition-and-fees\/index.php\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.duq.edu\/admission-and-aid\/financial-aid-and-scholarships\/types-of-financial-aid\/index.php\" target=\"_blank\" rel=\"noopener\">Financial Aid<\/a><\/li>\r\n \t<li><a title=\"Mary Pappert School of Music at Duquesne University\" href=\"https:\/\/www.duq.edu\/academics\/colleges-and-schools\/music\/music-admissions\/music-awards-ug.php\" target=\"_blank\" rel=\"noopener\">Undergraduate Scholarship Opportunities<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.duq.edu\/academics\/colleges-and-schools\/music\/music-admissions\/music-awards-gr.php\" target=\"_blank\" rel=\"noopener\">Graduate Scholarship\/Assistantship Opportunities<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.duq.edu\/academics\/colleges-and-schools\/music\/city-music-center\/summer-music-series.php\" target=\"_blank\" rel=\"noopener\">Summer Music Series<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_yoast_wpseo_focuskw_text_input%":"Mary Pappert School of Music at Duquesne University","%_yoast_wpseo_focuskw%":"Mary Pappert School of Music at Duquesne University","%_yoast_wpseo_title%":"Mary Pappert School of Music, Duquesne University","%_yoast_wpseo_metadesc%":"Your future in music can begin at the Mary Pappert School of Music, Duquesne University in performance, technology, education, or music therapy.","%_yoast_wpseo_linkdex%":"67","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"488","%_yoast_wpseo_primary_schools_graduateschools_majors%":"564","%_thumbnail_id%":"24832","%_oembed_4bb9751db6b3ce96cea5c6009225bc60%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/e9llThjMUV0?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_4bb9751db6b3ce96cea5c6009225bc60%":"1550696048","%_oembed_babcb9b55116df4d1246f394f934684b%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/HLzI_0PRB3w?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_babcb9b55116df4d1246f394f934684b%":"1550696048","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_87368960eab5b327efb636f5a1ae6ed1%":"<iframe title=\"Alumni Perspectives - Rose French\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/e9llThjMUV0?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_87368960eab5b327efb636f5a1ae6ed1%":"1567720645","%_oembed_785116b421bb0300897f1e9253c71c98%":"<iframe title=\"New Solid State Logic Console at the Mary Pappert School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/HLzI_0PRB3w?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_785116b421bb0300897f1e9253c71c98%":"1567720645","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_wp_old_slug%":"mary-pappert-school-of-music-at-duquesne-university","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_978590cf5aa3a0987f6377795c3985fa%":"<iframe title=\"Mary Pappert School of Music Trailer\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/gLwjbDOra6Q?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_978590cf5aa3a0987f6377795c3985fa%":"1683064013","%_oembed_35b0ff38158fb03ee10ad428311030e8%":"<iframe title=\"&quot;Farandole&quot; from L&#039;Arl\u00e9sienne, Duquesne Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/IE9BrdK6dPU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_35b0ff38158fb03ee10ad428311030e8%":"1683064014","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_8c931a3788147a60c1d257109045f69e%":"<iframe title=\"Mary Pappert School of Music Trailer\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/gLwjbDOra6Q?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_8c931a3788147a60c1d257109045f69e%":"1701555473","%_oembed_7cae7a6102b6f3985d9873b55de64c1c%":"<iframe title=\"&quot;Farandole&quot; from L&#039;Arl\u00e9sienne, Duquesne Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/IE9BrdK6dPU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_7cae7a6102b6f3985d9873b55de64c1c%":"1701555473","taxonomy=post_tag":"College of Music, Duquesne University, major in music, majoring in music, Mary Pappert School of Music, Mary Pappert School of Music at Duquesne University, Music colleges, music degree, music degrees, music education, music major, music school, music therapy, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Music Business, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/Production\/Engineering, Sacred Music","taxonomy=schools_majors":"Minor in music, Music (B.A.), Music Business, Music Education, Music Technology, Music Therapy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Recording\/ Production\/ Engineering, Sacred Music","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":16439,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"University of Cincinnati College-Conservatory of Music (CCM)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Cincinnati College-Conservatory of Music (CCM)\" width=\"300\" height=\"150\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/08\/CCM-music-campus-300x150.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-cincinnati-college-conservatory-of-music-ccm\/\" class=\"fc-post-link\">University of Cincinnati College-Conservatory of Music (CCM)<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"39.12969","lng":"-84.51821","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-cincinnati-college-conservatory-of-music-ccm\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]Nationally ranked and internationally renowned, the University of Cincinnati College-Conservatory of Music (CCM) is a preeminent institution for the performing and media arts. Declared <b>\u201cone of this country's leading conservatories\u201d<\/b> by the New York Times, CCM provides life-changing experiences within a highly creative and multidisciplinary artistic environment.\r\n\r\nCCM offers <b>10 degree types<\/b> (BA, BFA, BM, MA, MFA, MM, MME, AD, DMA, PhD) in nearly <strong>120 possible majors<\/strong>, along with a wide variety of pre-collegiate and post-graduate programs and workshops. CCM also offers a graduate certificate in <strong>Music Pedagogy<\/strong>, along with academic minors in both <strong>Music<\/strong> and <strong>Media Production<\/strong>.\r\n\r\nThe synergy created by housing CCM within a comprehensive public university gives the college its unique character and defines its objective:\u00a0<b>to educate and inspire the whole artist and scholar for positions on the world stage.<\/b>\r\n\r\nCCM provides students with professionally-oriented immersive experiences in order to prepare them to enter directly into performing and media arts careers. The school's roster of eminent faculty regularly receives distinguished honors for creative and scholarly work, and its alumni have achieved notable success in the performing and media arts.\r\n\r\nMore than 150 internationally recognized faculty members work with students from around the world, specializing in:\r\n\r\n\u2022 Composition\/Musicology\/Theory\r\n\u2022 Ensembles and Conducting (Chamber Music, Choral Studies, Commercial Music Production, Jazz Studies, Orchestral Studies and Wind Studies)\r\n\u2022 General Studies\r\n\u2022 Keyboard Studies (Harpsichord, Organ and Piano)\r\n\u2022 Media Production\r\n\u2022 Music Education\r\n\u2022 Performance Studies (Strings, Voice and Woodwinds\/Brass\/Percussion)\r\n\u2022 Theatre Arts, Production and Arts Administration (Acting, Arts Administration, Dance, Musical Theatre, Opera and Theatre Design and Production).\r\n\r\nProfessional development and entrepreneurial acumen are a vital part of the CCM experience. Faculty mentorship along with the \u201cManaging Professional Performance Careers\u201d course provides a foundation for transitioning to life after graduation. Select programs also host Senior Showcases in industry hotspots.\r\n\r\n<i><b>CCM ranks in top 10 most represented colleges on Broadway!\u00a0<\/b><\/i>\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=LSRM1sD96P4\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=Bri6oewRmm4\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"26091,26089,26090,26092\" img_size=\"600x400\" onclick=\"\" css=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"97\" title=\"true\" description=\"false\" ajax=\"false\"][ultimate_google_map lat=\"39.12969\" lng=\"-84.51821\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"University of Cincinnati College-Conservatory of Music (CCM)","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-cincinnati-college-conservatory-of-music-ccm\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Cincinnati College-Conservatory of Music (CCM)\" width=\"300\" height=\"150\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/08\/CCM-music-campus-300x150.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"CCM, College of Music, Music colleges, music conservatory, music education, music major, School of Music, University of Cincinnati, University of Cincinnati College-Conservatory of Music","%easyindexInvalidate%":"1","%_edit_lock%":"1727464170:4","%_edit_last%":"4","%ccft_post_comment_title%":"","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"39.12969","%_wpgmp_metabox_longitude%":"-84.51821","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"16279","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"26122","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"CalArts School of Music\" href=\"http:\/\/ccm.uc.edu\/\" target=\"_blank\" rel=\"noopener\">Conservatory of Music Homepage<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/ccm.uc.edu\/areas-of-study.html\" target=\"_blank\" rel=\"noopener\">Majors<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/ccm.uc.edu\/overview\/directory.html\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/ccm.uc.edu\/admissions-and-aid\/admissions.html\" target=\"_blank\" rel=\"noopener\">Application<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/ccm.uc.edu\/admissions-and-aid\/admissions\/auditions.html\" target=\"_blank\" rel=\"noopener\">Audition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.uc.edu\/bursar\/fees.html\" target=\"_blank\" rel=\"noopener\">Tuition and Fees<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/ccm.uc.edu\/admissions-and-aid\/financial-aid.html\" target=\"_blank\" rel=\"noopener\">Financial Aid and Scholarships<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/ccm.uc.edu\/arts4all\/summer.html\" target=\"_blank\" rel=\"noopener\">Summer Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/ccm.uc.edu\/areas-of-study.html\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/alumni.uc.edu\/about-us\/notable-alumni.html\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"","%_thumbnail_id%":"16285","%_oembed_b63244326147d003e0a801605368c9bc%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/yzS_6Ps_n-A?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_b63244326147d003e0a801605368c9bc%":"1503008760","%_oembed_f545221ded8f81979e25346ccec11356%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/PMq6DIDzGxg?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_f545221ded8f81979e25346ccec11356%":"1503008760","%_yoast_wpseo_focuskw_text_input%":"University of Cincinnati College-Conservatory of Music (CCM)","%_yoast_wpseo_focuskw%":"University of Cincinnati College-Conservatory of Music (CCM)","%_yoast_wpseo_title%":"University of Cincinnati College-Conservatory of Music (CCM)","%_yoast_wpseo_metadesc%":"University of Cincinnati College-Conservatory of Music (CCM) is a preeminent institution for the performing and media arts. CCM\u2019s world-class facilities","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_5f64413fd15f8ca05520918256faa38f%":"<iframe title=\"UC&#039;s College-Conservatory of Music: Arts in Harmony\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/yzS_6Ps_n-A?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_5f64413fd15f8ca05520918256faa38f%":"1567723530","%_oembed_e4dc20b4724bc8ec9ef821641762648b%":"<iframe title=\"A 360-Degree Look at the CCM Concert Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/PMq6DIDzGxg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_e4dc20b4724bc8ec9ef821641762648b%":"1567723530","%_oembed_4b13155d49627ab00b1bc170e5014046%":"<iframe title=\"A Virtual Tour of CCM Village at the University of Cincinnati\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/uhzzcAhuYXA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_4b13155d49627ab00b1bc170e5014046%":"1603211701","%_oembed_2da55c60f399a84d4e4fdc1fc537a211%":"<iframe title=\"CCMONSTAGE: The CCM Philharmonia&#039;s Season-Opening Concert (Friday, Sept. 20, 2019)\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/No46bqlCN-U?start=582&feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_2da55c60f399a84d4e4fdc1fc537a211%":"1603211702","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_oembed_1e430a3a3caa7116c0d9f23f0cfd8e80%":"<iframe title=\"The CCM Student Experience\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/4db19QLu6ik?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_1e430a3a3caa7116c0d9f23f0cfd8e80%":"1628106683","%_oembed_a40d791c4051284fd9aee8dae641ca7c%":"<iframe title=\"CCMONSTAGE Online Excerpt: &#039;Don Giovanni&#039; Sextet from CCM&#039;s Spring Opera Gala\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/hAXCrvmDINg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_a40d791c4051284fd9aee8dae641ca7c%":"1628106684","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_bb7f167e5afc0aed441ee2940d966056%":"<iframe title=\"CCM: Next Lives Here\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/aPwgrbKN10g?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_bb7f167e5afc0aed441ee2940d966056%":"1693505362","%_oembed_b93dd24c6d08e4041c3e5855d6747759%":"<iframe title=\"The CCM Student Experience\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/4db19QLu6ik?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_b93dd24c6d08e4041c3e5855d6747759%":"1693505362","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_2fc6fc0b227d3c7e4dd4e0e3c93db0af%":"<iframe title=\"CCM: Next Lives Here\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/aPwgrbKN10g?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_2fc6fc0b227d3c7e4dd4e0e3c93db0af%":"1701555876","%_oembed_2553d0aa2a232306011d1c88a26ca00a%":"<iframe title=\"The CCM Student Experience\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/4db19QLu6ik?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_2553d0aa2a232306011d1c88a26ca00a%":"1701555876","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_oembed_f520356ebf7b6502c882eab072d1d4d3%":"<iframe title=\"CCM Campus Tour\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/LSRM1sD96P4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_f520356ebf7b6502c882eab072d1d4d3%":"1726006985","%_oembed_06735effd2f052c4aef2062168048cb1%":"<iframe title=\"CCM: Welcome To Your Next Stage\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Bri6oewRmm4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_06735effd2f052c4aef2062168048cb1%":"1726006985","taxonomy=post_tag":"CCM, College of Music, Music colleges, music conservatory, music education, music major, School of Music, University of Cincinnati, University of Cincinnati College-Conservatory of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Composition &amp; Theory, Conducting, Music Education, Musicology, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Recording\/Production\/Engineering","taxonomy=schools_majors":"Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Composition &amp; Theory, Music Education, Music Technology, Musical Theatre, Musicology\/ Music History, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":16274,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"Loyola Marymount University Department of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Loyola Marymount University Department of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/07\/loyolanew-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/loyola-marymount-university-department-of-music\/\" class=\"fc-post-link\">Loyola Marymount University Department of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"33.9696926","lng":"-118.41863060000003","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/loyola-marymount-university-department-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<span style=\"font-size: 14pt;\">LMU Music offers a broad array of major and minor concentrations. Students choose from <strong>Contemporary Styles and Practices (music technology + popular music), Instrumental Studies, Vocal Studies, Theory\/Composition, Musicology, Ethnomusicology, and Conducting.<\/strong> Students are also able to choose from among 56 minor undergraduate degrees and programs, including Music &amp; Social Justice.<\/span>\r\n<h2>Students receive:<\/h2>\r\n\u2022 Close mentorship and training.\r\n\u2022 All courses taught by world-renowned faculty, with small classes and a personalized approach.\r\n\u2022 Many opportunities to perform in ensembles and as soloists.\r\n\u2022 Close-knit music community.\r\n\u2022 State-of-the-art facilities include the new technology lab.\r\n\u2022 Opportunities to serve marginalized populations.\r\n<h2>Unique Features of LMU<\/h2>\r\nOur Bachelor of Arts degree offers an innovative and balanced curriculum specializing in music performance, contemporary practices, musicianship, and historical perspectives. Students can choose to major or minor in music; for majors, <strong>private lessons are covered by university tuition<\/strong> and professional accompanists are provided for lessons, rehearsals, and public performances.\r\n\r\nLocated in Los Angeles, one of the most culturally and musically vibrant cities in the country and a music industry hub, LMU offers students access to a wide variety of musical opportunities and events both on and off campus.\r\n\r\nLMU graduates are trained for <strong>careers as musicologists, composers, performers, conductors, arts administrators, and music educators, as well as in fields outside of music.<\/strong> Many go on to graduate school in music as well as other areas of interest.\r\n\r\nTravel opportunities for the LMU Choirs include a performance at Carnegie Hall in June 2022, and an international performance tour to Costa Rice in Spring 2023. Voice majors in the Sinatra Opera Workshop receive financial assistance to study and perform with programs overseas, including the Frost School of Music Salzburg Summer Festival and the Hawaii Performing Arts Festival.[\/vc_column_text][vc_column_text][\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_video link=\"https:\/\/www.youtube.com\/watch?v=qdraauX_m9M\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][vc_gallery type=\"image_grid\" images=\"16134,16173,16135,16133\" img_size=\"300x200\" onclick=\"\"][gravityform id=\"96\" title=\"true\" description=\"false\" ajax=\"false\"][ultimate_google_map lat=\"33.9696926\" lng=\"-118.41863060000003\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Loyola Marymount University Department of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/loyola-marymount-university-department-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Loyola Marymount University Department of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/07\/loyolanew-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Loyola Marymount University, Loyola Marymount University Department of Music, major in music, majoring in music, Music colleges, music degree, music degrees, music education, music major, music school, music students, School of Music","%easyindexInvalidate%":"1","%_edit_lock%":"1721096202:9","%_edit_last%":"9","%ccft_post_comment_title%":"","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"33.9696926","%_wpgmp_metabox_longitude%":"-118.41863060000003","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"4\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"16139","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"16136","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"CalArts School of Music\" href=\"http:\/\/cfa.lmu.edu\/programs\/music\/\" target=\"_blank\" rel=\"noopener\">Music Homepage<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"http:\/\/cfa.lmu.edu\/programs\/music\/program\/\" target=\"_blank\" rel=\"noopener\">Concentrations<\/a><\/li>\r\n \t<li><a href=\"http:\/\/cfa.lmu.edu\/programs\/music\/academics\/\" target=\"_blank\" rel=\"noopener\">Curriculum<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"http:\/\/cfa.lmu.edu\/programs\/music\/faculty\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.lmu.edu\/apply\/\" target=\"_blank\" rel=\"noopener\">Apply<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/cfa.lmu.edu\/programs\/music\/auditions\/\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/financialaid.lmu.edu\/generalinformation\/costofattendance\/\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/financialaid.lmu.edu\/prospectivestudents\/scholarships\/\" target=\"_blank\" rel=\"noopener\">Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/careers.lmu.edu\/\" target=\"_blank\" rel=\"noopener\">Career and Professional Development<\/a><\/li>\r\n \t<li><a href=\"https:\/\/cfa.lmu.edu\/programs\/music\/beyondtheclassroom\/featuredalumni\/\" target=\"_blank\" rel=\"noopener\">Featured Alumni<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"351","%_thumbnail_id%":"25899","%_yoast_wpseo_focuskw_text_input%":"Loyola Marymount University Department of Music","%_yoast_wpseo_focuskw%":"Loyola Marymount University Department of Music","%_yoast_wpseo_title%":"Loyola Marymount University Department of Music","%_yoast_wpseo_metadesc%":"Through its state-of-the-art facilities and ambitious annual calendar of performances and events, Loyola Marymount University Department of Music invites","%_yoast_wpseo_linkdex%":"62","%_oembed_b2eeae5219ffb18fc660c949a79f0a83%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/qdraauX_m9M?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_b2eeae5219ffb18fc660c949a79f0a83%":"1499898393","%_oembed_340ece732f9ec7af957380d1f2ea9ff9%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/c6WN7nUQjVc?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_340ece732f9ec7af957380d1f2ea9ff9%":"1499898393","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"483","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_f6968ef9efa23d900ca7d457ca97cffa%":"<iframe title=\"Drone Tour of the LMU Campus\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/qdraauX_m9M?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_f6968ef9efa23d900ca7d457ca97cffa%":"1567747324","%_oembed_37c54cf6f2df9e093ab8f0396893c73f%":"{{unknown}}","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_03f0ac9bbef8cc0fa1aa63a819911b7b%":"<iframe title=\"Drone Tour of the LMU Campus\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/qdraauX_m9M?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_03f0ac9bbef8cc0fa1aa63a819911b7b%":"1701554216","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"Loyola Marymount University, Loyola Marymount University Department of Music, major in music, majoring in music, Music colleges, music degree, music degrees, music education, music major, music school, music students, School of Music","taxonomy=schools_degrees":"Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Composition &amp; Theory, Conducting, Ethnomusicology, Minor in music, Music (B.A.), Musicology\/ Music History, Performance - Instrumental, Performance - Vocal","taxonomy=schools_Region":"Western US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png"},"id":16130,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png","name":"Western US Music Schools","id":"3","type":"category"}]},{"source":"post","title":"Bard College Conservatory of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bard College Conservatory of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/06\/Bard-University-string-music-students-3-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/bard-college-conservatory-of-music\/\" class=\"fc-post-link\">Bard College Conservatory of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"42.020823","lng":"-73.916647","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/bard-college-conservatory-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]\r\n<p class=\"intro\">Led by world-renowned composer and conductor Tan Dun, <strong>all undergraduates at Bard College Conservatory of Music pursue a five-year program leading to two degrees:<\/strong> the Bachelor of Music degree and the Bachelor of Arts degree in a field other than music.<\/p>\r\nThe innovative curriculum of The Bard College Conservatory of Music is guided by the principle that musicians should be broadly educated in the liberal arts and sciences in order to achieve their greatest potential.\r\n\r\n<strong>Why pursue a double degree in music and liberal arts at Bard?<\/strong>\r\n<ul>\r\n \t<li>Supportive community that equally serves the musical and academic goals of young musicians.<\/li>\r\n \t<li>Combine world-class musical training with the broad experience of a strong liberal arts academic program.<\/li>\r\n<\/ul>\r\n<strong>Major Performance Opportunities:<\/strong>\r\n<ul>\r\n \t<li>Bard Conservatory Orchestra<\/li>\r\n \t<li>Chamber Music<\/li>\r\n \t<li>Solo Recitals<\/li>\r\n \t<li>Annual Concerto Competition<\/li>\r\n \t<li>Orchestra Tours<\/li>\r\n \t<li>Opera Workshop &amp; Mainstage Opera<\/li>\r\n \t<li>Bard Chamber Singers &amp; Symphonic Chorus<\/li>\r\n<\/ul>\r\n<strong>Financial Aid:<\/strong>\r\n<ul>\r\n \t<li>Merit-based and need-based awards available<\/li>\r\n \t<li>Special merit scholarships available for students in composition, double bass,oboe, bassoon, and brass instruments<\/li>\r\n \t<li>Bard Conservatory is scholarship partners with the <a href=\"https:\/\/www.sphinxmusic.org\/scholarship-portal\/\" target=\"_blank\" rel=\"noopener\">Sphinx Organization College-Bound Program<\/a><\/li>\r\n<\/ul>\r\nBard Conservatory is also home to the <strong>US-China Music Institute<\/strong>. In partnership with the Central Conservatory of Music (Beijing, China), Bard Conservatory offers students the opportunity to pursue performance degrees in the study of traditional Chinese instruments.\r\n\r\n<strong><a href=\"https:\/\/bardconservatory.college-tour.com\/about-us\/visiting-bard\" target=\"_blank\" rel=\"noopener\">Visit Bard<\/a><\/strong>[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=CD4UoyC5saw&amp;feature=youtu.be\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=Tym79fb3lNA&amp;feature=youtu.be\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"25773,25772,25775,25774\" img_size=\"600x400\" onclick=\"\" css=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"95\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"42.020823\" lng=\"-73.916647\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Bard College Conservatory of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/bard-college-conservatory-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bard College Conservatory of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/06\/Bard-University-string-music-students-3-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Bard College Conservatory of Music, College of Music, majoring in music, Music colleges, music conservatory, music degree, music degrees, music education, music school, music students, School of Music","%easyindexInvalidate%":"1","%_edit_lock%":"1731016923:4","%_edit_last%":"4","%ccft_post_comment_title%":"","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.020823","%_wpgmp_metabox_longitude%":"-73.916647","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"90","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"16090","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"25771","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/bardconservatory.college-tour.com\/homepage\" target=\"_blank\" rel=\"noopener\">Conservatory of Music Homepage<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/bardconservatory.college-tour.com\/about-us\/our-faculty\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.bard.edu\/conservatory\/undergraduate\/admission\/\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/www.bard.edu\/conservatory\/undergraduate\/requirements\/\" target=\"_blank\" rel=\"noopener\">Applications<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/www.bard.edu\/conservatory\/undergraduate\/audition\/\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.bard.edu\/studentaccounts\/fees\/\" target=\"_blank\" rel=\"noopener\">Tuition and Fees<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/bardconservatory.college-tour.com\/programs\/undergraduate-double-degree-program\/scholarships-financial-aid\" target=\"_blank\" rel=\"noopener\">Scholarships and Financial Aid<\/a><\/li>\r\n \t<li><a title=\"CalArts School of Music\" href=\"https:\/\/www.bard.edu\/conservatory\/admission\/\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.bard.edu\/conservatory\/undergraduate\/student\/\" target=\"_blank\" rel=\"noopener\">Alumni and Student Stories<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_yoast_wpseo_focuskw_text_input%":"Bard College Conservatory of Music","%_yoast_wpseo_focuskw%":"Bard College Conservatory of Music","%_yoast_wpseo_title%":"Bard College Conservatory of Music","%_yoast_wpseo_metadesc%":"All Bard College Conservatory of Music undergraduates pursue a five-year program leading to two degrees: the bachelor of music degree and the bachelor","%_yoast_wpseo_linkdex%":"69","%_oembed_d8303afc3a5acc917bd19d57dd524647%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/bT3RtghMyLk?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_d8303afc3a5acc917bd19d57dd524647%":"1498076991","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_6db217ca5b300833b011b56f64146afe%":"<iframe title=\"Why Bard Conservatory?\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/CD4UoyC5saw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_6db217ca5b300833b011b56f64146afe%":"1561492770","%_oembed_3f3ae465c8366d8644e827f637835732%":"<iframe title=\"Why Bard Conservatory?\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/CD4UoyC5saw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_3f3ae465c8366d8644e827f637835732%":"1567732762","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_73d5e58eb36aa57283d55744c7c1b777%":"<iframe title=\"Why Bard Conservatory?\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/CD4UoyC5saw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_73d5e58eb36aa57283d55744c7c1b777%":"1593196014","%_oembed_be68b51c13921711a3a2e79f03346b77%":"<iframe title=\"Javen Lara &#039;21: Viola Performance, Italian Studies\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Tym79fb3lNA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_be68b51c13921711a3a2e79f03346b77%":"1593196014","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_c3b720dac18a41b9974bf08cd2180932%":"<iframe title=\"Why Bard Conservatory?\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/CD4UoyC5saw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_c3b720dac18a41b9974bf08cd2180932%":"1701545433","%_oembed_c08962dafea09057ff4fac30f09a7b51%":"<iframe title=\"Javen Lara &#039;21: Viola Performance, Italian Studies\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Tym79fb3lNA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_c08962dafea09057ff4fac30f09a7b51%":"1701545433","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_thumbnail_id%":"25780","taxonomy=post_tag":"Bard College Conservatory of Music, College of Music, majoring in music, Music colleges, music conservatory, music degree, music degrees, music education, music school, music students, School of Music","taxonomy=schools_degrees":"Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Composition &amp; Theory, Performance - Instrumental, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":16081,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Northeastern University Department of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Northeastern University music singers\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/01\/Northeastern-University-music-1-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/northeastern-university-department-of-music\/\" class=\"fc-post-link\">Northeastern University Department of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"42.339169","lng":"-71.088474","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/northeastern-university-department-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\">At Northeastern, every discipline is driven by an entrepreneurial spirit and a dedicated focus on maximizing positive, real-world impact on societies, economies and cultures.<\/p>\r\nNortheastern University\u2019s Department of Music offers undergraduate and graduate majors, minors, and non-majors a cross-disciplinary approach to the study and practice of music, underscored by\u00a0<b>real-world experiential learning (including professional \u201cco-op\u201d semesters), cutting-edge technology, and global experience opportunities.<\/b>\r\n\r\nMost music undergraduates complete at least one paid six-month co-op.\u00a0<b>Recent co-op placements include placements at:<\/b>\r\n\r\n<i>\u2022 Late Night with Seth Meyers<\/i>\r\n\r\n<i>\u2022 The Late Show with Stephen Colbert<\/i>\r\n\r\n\u2022 Apple Music\r\n\r\n\u2022 Sony Music\r\n\r\n\u2022 Bose\r\n\r\n\u2022 Columbia Records\r\n\r\n\u2022 Epic Records\r\n\r\n\u2022 Lionfish Music LLC\r\n\r\n\u2022 House of Blues\r\n\r\n\u2022 Universal Music Publishing\r\n\r\n\u2022 Live Nation\r\n\r\n\u2022 Boston Symphony Orchestra\r\n\r\n\u2022 Calling All Crows\r\n\r\nAll programs of study are designed to facilitate\u00a0flexible options\u00a0that allow the integration of each student\u2019s evolving interests and aspirations.\r\n\r\nUndergraduate programs include:\r\n\r\n\u2022 B.A. in Music (musicology, ethnomusicology, music theory, and composition, among others);\r\n\u2022 B.S. in Music and Psychology\r\n\u2022 B.S. with a concentration in Music Technology or Music Industry;\r\n\u2022 B.S. in Music and Communication Studies with a concentration in Music Industry;\r\n\u2022 B.S. in Physics and Music with a concentration in Music Technology\r\n\u2022\u00a0B.S. in Engineering and Music with a concentration in Music Technology\r\n\u2022\u00a0B.S. in Game Design and Music with a concentration in Music Technology\r\n\r\nand\u00a0<b>flexible opportunities for combined majors<\/b>\u00a0across colleges and areas of study (e.g., the humanities, sciences, business and law).\r\n\r\nWe also offer a variety of minors in music disciplines that supplement major concentrations.\r\n\r\nWhatever the chosen curricular path, all students at Northeastern have access through the Department of Music to music making at every level of ability through individual lessons and small and large ensembles. Students interested in applying should explore our opportunities for portfolio submissions.\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_separator border_width=\"10\" css=\".vc_custom_1547153534603{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_gallery type=\"image_grid\" images=\"15692,25505,18833,18836\" img_size=\"600x400\" onclick=\"\"][\/vc_column_inner][\/vc_row_inner][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"90\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"42.339169\" lng=\"-71.088474\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Northeastern University Department of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/northeastern-university-department-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Northeastern University music singers\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/01\/Northeastern-University-music-1-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, Entrepreneurship, major in music, majoring in music, Music colleges, music education, music industry, music major, Northeastern University, Northeastern University Department of Music, School of Music","%easyindexInvalidate%":"1","%_edit_lock%":"1737499078:4","%_edit_last%":"4","%ccft_post_comment_title%":"","%_wpb_vc_js_status%":"false","%_wpb_shortcodes_custom_css%":".vc_custom_1547153534603{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.339169","%_wpgmp_metabox_longitude%":"-71.088474","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"15701","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"25507","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/camd.northeastern.edu\/music\/\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/camd.northeastern.edu\/music\/undergraduate\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Majors Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/camd.northeastern.edu\/undergraduate-admissions\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Admissions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/camd.northeastern.edu\/undergraduate-admissions\/portfolios\/\" target=\"_blank\" rel=\"noopener\">Portfolio Submission<\/a><\/li>\r\n \t<li><a href=\"https:\/\/camd.northeastern.edu\/music\/co-op-experiential-learning\/\" target=\"_blank\" rel=\"noopener\">Co-op &amp; Experiential Learning<\/a><\/li>\r\n \t<li><a href=\"https:\/\/camd.northeastern.edu\/programs\/arts-administration-and-cultural-entrepreneurship-ms\/\" target=\"_blank\" rel=\"noopener\">Master's in Arts Administration &amp; Cultural Entrepreneurship<\/a><\/li>\r\n \t<li><a href=\"https:\/\/camd.northeastern.edu\/music\/faculty-and-staff-directory\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/studentfinance.northeastern.edu\/billing-payments\/tuition-and-fees\/\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/studentfinance.northeastern.edu\/applying-for-aid\/undergraduate\/types-of-aid\/scholarships\/\" target=\"_blank\" rel=\"noopener\">Scholarships &amp; Financial Aid<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_thumbnail_id%":"18832","%_yoast_wpseo_focuskw_text_input%":"Northeastern University Department of Music","%_yoast_wpseo_focuskw%":"Northeastern University Department of Music","%_yoast_wpseo_title%":"Northeastern University Department of Music","%_yoast_wpseo_metadesc%":"The Northeastern University Department of Music resides in the College of Arts, Media and Design. Here, every discipline is driven by an entrepreneurial","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"535","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_monsterinsights_sitenote_active%":"0","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"College of Music, Entrepreneurship, major in music, majoring in music, Music colleges, music education, music industry, music major, Northeastern University, Northeastern University Department of Music, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Arts Management, Music Industry","taxonomy=schools_majors":"Computer Music, Minor in music, Music (B.A.), Music Industry, Music Technology, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":15705,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"University of Michigan School of Music, Theatre &#038; Dance","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Michigan School of Music, Theatre &#038; Dance\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/08\/Michigan-Music-1-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-michigan-school-of-music\/\" class=\"fc-post-link\">University of Michigan School of Music, Theatre &#038; Dance<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"42.29039","lng":"-83.720782","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-michigan-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\"><strong>At the University of Michigan School of Music, Theatre &amp; Dance (SMTD), a renowned school of performing arts housed within a leading Big Ten university, your experience will be as multifaceted as you are.<\/strong><\/p>\r\nSMTD offers an unparalleled synergy of scholarship, artistry, and comprehensive education in performance, liberal arts, research, and pedagogy. <strong>In addition to performance and music education, SMTD offers outstanding programs in:<\/strong>\r\n\r\n\u2022 Composition\r\n\u2022 General Music Studies\r\n\u2022 Jazz\r\n\u2022 Musical Theatre\r\n\u2022 Performing Arts Technology\r\n\u2022 Voice &amp; Opera\r\n\r\nSMTD is revolutionizing the way performing arts students prepare for their future. Opportunities include:\r\n\r\n\u2022 Study one-on-one with our highly skilled, dedicated teachers and world-class artists in a conservatory-style setting. With <strong>more than 215 faculty members<\/strong>, you are guaranteed individualized mentorship.\r\n\r\n\u2022 Lay the groundwork for your future with SMTD\u2019s EXCEL Lab, our <strong>career planning and entrepreneurship center<\/strong> that offers mentorship, coursework, and funding tailored to the performing arts to help students take the next step in their professional development.\r\n\r\n\u2022 Perform concerts with a large ensemble at the historic Hill Auditorium or take center stage at our Arthur Miller Theatre, the only theatre in the world to bear the author\u2019s name. SMTD puts on <strong>more than 900 performance events each year<\/strong>, from solo and chamber music recitals to large choir, band, orchestra, and jazz ensemble concerts, and from early music to electronic music.\r\n\r\n\u2022 Collaborate with other musicians, dancers, actors, directors, choreographers, and more to bring world-renowned pieces \u2013 or an idea of your own \u2013 to life.\r\n\r\n\u2022 Expand your studies to pursue coursework or a dual major in U-M\u2019s top programs in liberal arts, business, engineering, and more. There are <strong>over 100 different majors and minors<\/strong> available to Michigan students.\r\n\r\n\u2022 Explore the classic college experience at a Big Ten university and join an expansive alumni network of over 630,000 living alums.\r\n[\/vc_column_text][\/vc_column][\/vc_row][vc_row][vc_column][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=PMGeaD7aocE\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=axZZEuk7MVY\"][\/vc_column_inner][\/vc_row_inner][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][vc_separator align=\"align_left\" border_width=\"10\"][vc_gallery type=\"image_grid\" images=\"26034,26035,26030,26033\" img_size=\"600x400\" css=\"\"][\/vc_column][\/vc_row][vc_row][vc_column][gravityform id=\"86\" title=\"true\" description=\"false\" ajax=\"false\"][ultimate_google_map lat=\"42.29039\" lng=\"-83.720782\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"University of Michigan School of Music, Theatre &#038; Dance","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-michigan-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Michigan School of Music, Theatre &#038; Dance\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/08\/Michigan-Music-1-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, majoring in music, Music colleges, music school, music students, preparing to major in music, School of Music, University of Michigan, University of Michigan School of Music","%easyindexInvalidate%":"1","%_edit_lock%":"1724964605:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"42.29039","%_wpgmp_metabox_longitude%":"-83.720782","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"University of Michigan School of Music","%_yoast_wpseo_focuskw%":"University of Michigan School of Music","%_yoast_wpseo_title%":"University of Michigan School of Music, Theatre & Dance","%_yoast_wpseo_metadesc%":"The University of Michigan School of Music, Theatre & Dance (SMTD) is unique amongst its peer institutions: It is a top performing arts school, featuring","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_content_score%":"30","%majoring-in-music_layout%":"25","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"26031","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"26040","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/admissions\/undergraduate\/undergraduate-degrees-minors\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Majors<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/admissions\/graduate\/graduate-degrees\/\" target=\"_blank\" rel=\"noopener\">Graduate Majors<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/faculty-and-staff-directory\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/admissions\/undergraduate-admissions\/apply\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Applications<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/admissions\/undergraduate-admissions\/auditions-interviews\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/admissions\/undergraduate\/affording-your-education\/#merit\" target=\"_blank\" rel=\"noopener\">Undergraduate Tuition &amp; Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/admissions\/graduate-admissions\/apply\/\" target=\"_blank\" rel=\"noopener\">Graduate Applications<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/admissions\/graduate-admissions\/auditions-interviews\/\" target=\"_blank\" rel=\"noopener\">Graduate Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/admissions\/graduate-admissions\/cost-scholarships-financial-aid\/\" target=\"_blank\" rel=\"noopener\">Graduate Tuition &amp; Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/programs-degrees\/youth-adult-programs\/youth-programs\/mpulse\/\" target=\"_blank\" rel=\"noopener\">MPulse Summer Institutes<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/muse\/winter-2024\/alumni-updates\/\" target=\"_blank\" rel=\"noopener\">Highlighting Our Alumni<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/smtd-experience\/excel-lab\/\" target=\"_blank\" rel=\"noopener\">Entrepreneurship &amp; Career Center<\/a><\/li>\r\n \t<li><a href=\"https:\/\/smtd.umich.edu\/muse\/winter-2024\/student-updates\/\" target=\"_blank\" rel=\"noopener\">Current Student News<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"348","%_oembed_b78a3f71b085372d3d1269a830acd4bd%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/bynZmqZWnxM?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_b78a3f71b085372d3d1269a830acd4bd%":"1472672546","%_oembed_1611bd93a69068cd804e23898751f618%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/videoseries?list=PLVy2jdQD7GRy4oxqSXNWotCY1e2YovGJ_\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_1611bd93a69068cd804e23898751f618%":"1472775824","%_oembed_cd22c1c6b20f4307bd2975a0898d717a%":"{{unknown}}","%_oembed_30c484a7784b0d862c8221245049e5a5%":"{{unknown}}","%_oembed_71ae0db7f6e61ffd19b757ea6a0c207c%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/51589652\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"Timelapse - Lighthouse (Oct 2012)\" webkitallowfullscreen mozallowfullscreen allowfullscreen><\/iframe>","%_oembed_time_71ae0db7f6e61ffd19b757ea6a0c207c%":"1472776490","%_oembed_194608b679647cc449bbcf6824aeb1ab%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/mnddjEhQzlA?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_194608b679647cc449bbcf6824aeb1ab%":"1472776989","%_oembed_fde124ee5d738d67ead90f4b62de6282%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/zmim1SmZx78?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_fde124ee5d738d67ead90f4b62de6282%":"1473375335","%_wp_old_slug%":"university-michigan-school-music","%_oembed_5ef7b4ade2e28669df6512f4a670ed25%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/zmim1SmZx78?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_5ef7b4ade2e28669df6512f4a670ed25%":"1492868621","%_oembed_272dc437a0f1b3214a9988ff896afc2a%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/mnddjEhQzlA?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_272dc437a0f1b3214a9988ff896afc2a%":"1492868621","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%facebook-social%":"<a href=\"https:\/\/www.facebook.com\/umichsmtd\" rel=\"noopener\" target=\"_blank\">https:\/\/www.facebook.com\/umichsmtd<\/a>","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"<a href=\"https:\/\/twitter.com\/umichsmtd\" rel=\"noopener\" target=\"_blank\">https:\/\/twitter.com\/umichsmtd?lang=en<\/a>","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"<a href=\"https:\/\/www.instagram.com\/umichsmtd?hl=en\" rel=\"noopener\" target=\"_blank\">https:\/\/www.instagram.com\/umichsmtd?hl=en<\/a>","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"<a href=\"https:\/\/www.youtube.com\/channel\/UCSNJs3y43eryXwJEElDwcJg\" rel=\"noopener\" target=\"_blank\">https:\/\/www.youtube.com\/channel\/UCSNJs3y43eryXwJEElDwcJg<\/a>","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_4e422e7bb04ed78b8fe25105554b19f0%":"{{unknown}}","%_oembed_1a45b6905cbae3ce1cbbd7860ee09a97%":"<iframe title=\"Collage: A Virtual Concert Experience\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/wloNStv9udA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_1a45b6905cbae3ce1cbbd7860ee09a97%":"1629996120","%_oembed_e7abf6b31b9ce2db6dff2e9ee1c29c9a%":"<iframe title=\"Appalachian Spring by Aaron Copland \/\/ University of Michigan Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/zt3KX5wRXKg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_e7abf6b31b9ce2db6dff2e9ee1c29c9a%":"1629996120","%_thumbnail_id%":"26029","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_82fd8e11e20d42979d0e209f736f3dc1%":"<iframe title=\"Music From Auschwitz \/\/ Dance Band Arrangements by Members of the Auschwitz I Men\u2019s Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/4akD5gcxZAA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_82fd8e11e20d42979d0e209f736f3dc1%":"1661463928","%_oembed_a75708a5628b5eebf52a882444001444%":"<iframe title=\"Let Woman Choose Her Sphere \/\/ University of Michigan Concert Band \/\/ Courtney Snyder, conductor\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/fP1o3bFZF6E?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_a75708a5628b5eebf52a882444001444%":"1661464040","%_oembed_8e3d2ecdc1a918f006a99d5c4f2ecbf6%":"<iframe title=\"&quot;V.I.V. Rituals from Self to Divine&quot; by Alexia Benson \/\/ Andrew Lee Neer, conductor \/\/ UPO\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/chI0e9YNlvY?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_8e3d2ecdc1a918f006a99d5c4f2ecbf6%":"1692039567","%_oembed_4f221ad3708b1bc1e2bd41db8507b462%":"<iframe title=\"Michigan Minds | Dr. Antonio C. Cuyler\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/axZZEuk7MVY?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_4f221ad3708b1bc1e2bd41db8507b462%":"1692039568","%_oembed_fb5d1a1db31d9191fb92522e69b0d6dc%":"<iframe title=\"&quot;V.I.V. Rituals from Self to Divine&quot; by Alexia Benson \/\/ Andrew Lee Neer, conductor \/\/ UPO\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/chI0e9YNlvY?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_fb5d1a1db31d9191fb92522e69b0d6dc%":"1701542620","%_oembed_954f598f1fcf931ce9c43da17df10512%":"<iframe title=\"Michigan Minds | Dr. Antonio C. Cuyler\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/axZZEuk7MVY?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_954f598f1fcf931ce9c43da17df10512%":"1701542620","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_oembed_7110285c104a16473f5ed0862ad82624%":"<iframe title=\"&quot;Everything I Thought I Wanted&quot; by Robert Maggio \/\/ 6. endless possibilities \/\/ U-M Percussion Ens.\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/PMGeaD7aocE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_7110285c104a16473f5ed0862ad82624%":"1724886362","taxonomy=post_tag":"College of Music, majoring in music, Music colleges, music school, music students, preparing to major in music, School of Music, University of Michigan, University of Michigan School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Chamber Music, Collaborative Piano, Composition &amp; Theory, Conducting, Early Music\/ Historical Performance, Music Education, Music Technology, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Recording\/Production\/Engineering, Sacred Music","taxonomy=schools_majors":"Composition &amp; Theory, Minor in music, Music Education, Music Technology, Musical Theatre, Musicology\/ Music History, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":15196,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"Blair School of Music at Vanderbilt University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Blair School of Music at Vanderbilt University\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/08\/Vanderbilt-orchestra-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/blair-school-of-music-at-vanderbilt-university\/\" class=\"fc-post-link\">Blair School of Music at Vanderbilt University<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"36.14127","lng":"-86.80191","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/blair-school-of-music-at-vanderbilt-university\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<h3><strong>Experience world-class music training alongside a top-20 academic education at one of the few exclusively undergraduate music schools in the country.<\/strong><\/h3>\r\n<strong>Blair School of Music students are bright and versatile, with wide-ranging interests and ideas:\u2028<\/strong>\r\n\r\nWe believe Blair students\u2019 artistry is enriched by the intersection between the arts and other academic disciplines; students will graduate with Vanderbilt University\u2019s strong foundation in the liberal arts and sciences supporting Blair\u2019s intense training in music.\r\n\r\n\u2022 Located in Nashville, TN (known to the world as Music City)\r\n\r\n\u2022 Approximately 230 students\r\n\r\n\u2022 An exclusively undergraduate program\r\n\r\n\u2022 Approximately 350 performances | 50 masterclasses per academic year\r\n\r\n\u2022 4-to-1 student faculty ratio\r\n\r\n\u2022 The Bachelor of Music degree program is available in composition, jazz studies, and integrated studies (which combines a primary performance area or composition with a concentration in a second musical area)\r\n\r\n\u2022 The Bachelor of Musical Arts degree combines in-depth music study with a second minor or major in a field outside of music. This is available to majors in any classical music area, including composition, or jazz studies.\r\n\r\n\u2022 Blair students may pursue one of Vanderbilt\u2019s Pre-Professional programs alongside their music major (Pre-medicine, Pre-law, Pre-business, Pre-architecture).\r\n\r\n\u2022 Study abroad opportunities include Amsterdam, Berlin, Copenhagen, Sydney, and more.\r\n\r\n\u2022 Vanderbilt University offers a wide variety of undergraduate research opportunities.\r\n\r\n\u2022 87% of Blair Students received scholarship assistance (need-based and merit-based scholarships 2023-24).\r\n\r\n<strong>Blair graduates can be found throughout fields of performance, research, teaching and composition. They have been accepted for graduate study at top institutions around the world.<\/strong>\r\n\r\n<strong>Blair alumni also have pursued graduate work in disciplines as varied as entertainment law, music business, music therapy and cognition, medicine, and arts management.<\/strong>\r\n[\/vc_column_text][vc_column_text css=\"\" el_class=\"schools-links\"][acf field='school_links']\r\n<div class=\"schools-social-wrapper\">\r\n<div class=\"schools-social facebook-social\">[acf field='facebook-social']<\/div>\r\n<div class=\"schools-social twitter-social\">[acf field='twitter-social']<\/div>\r\n<div class=\"schools-social instagram-social\">[acf field='instagram-social']<\/div>\r\n<\/div>\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/OYlDWc9id0o\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/Ujs8mLhyzBc?\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"14989,14994,25974,25973\" img_size=\"600x400\" css=\"\"][gravityform id=\"84\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"36.14127\" lng=\"-86.80191\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Blair School of Music at Vanderbilt University","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/blair-school-of-music-at-vanderbilt-university\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Blair School of Music at Vanderbilt University\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/08\/Vanderbilt-orchestra-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Blair School of Music, College of Music, major in music, majoring in music, Music colleges, music education, music major, music school, music students, School of Music, Vanderbilt University","%easyindexInvalidate%":"1","%_edit_lock%":"1724352553:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"36.14127","%_wpgmp_metabox_longitude%":"-86.80191","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%majoring-in-music_layout%":"25","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"25159","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"25971","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/blair.vanderbilt.edu\/\" target=\"_blank\" rel=\"noopener\">Blair School of Music Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/blair.vanderbilt.edu\/academics\/?school=Blair+School+of+Music\" target=\"_blank\" rel=\"noopener\">Programs of Study<\/a><\/li>\r\n \t<li><a href=\"https:\/\/blair.vanderbilt.edu\/faculty\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/blair.vanderbilt.edu\/admissions\/#h2-how-to-apply\" target=\"_blank\" rel=\"noopener\">Application Instructions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/blair.vanderbilt.edu\/admissions\/prescreening-auditions\/\" target=\"_blank\" rel=\"noopener\">Prescreening &amp; Audition Repertoire<\/a><\/li>\r\n \t<li><a href=\"https:\/\/admissions.vanderbilt.edu\/affordability\/\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/blair.vanderbilt.edu\/admissions\/scholarship-information\/\" target=\"_blank\" rel=\"noopener\">Financial Aid\/Scholarship Opportunities<\/a><\/li>\r\n \t<li><a href=\"https:\/\/blair.vanderbilt.edu\/ensembles\/#h2-student-ensembles\" target=\"_blank\" rel=\"noopener\">Student Ensembles<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.vanderbilt.edu\/\" target=\"_blank\" rel=\"noopener\">Vanderbilt University<\/a><\/li>\r\n \t<li><a href=\"http:\/\/vu.edu\/visitblair\" target=\"_blank\" rel=\"noopener\">Visit Blair<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.vanderbilt.edu\/career\/start-here\/\" target=\"_blank\" rel=\"noopener\">Career Support<\/a><\/li>\r\n \t<li><a href=\"https:\/\/blair.vanderbilt.edu\/alumni\/alumni-profiles\/\" target=\"_blank\" rel=\"noopener\">Alumni Spotlights<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"348","%_oembed_3882d417bff39600e6a028e38bc10f65%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/videoseries?list=PL074BBF0BB0251DAD\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_3882d417bff39600e6a028e38bc10f65%":"1470425213","%_oembed_b35ea40a409d7b31cec33583ce8de4b4%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/videoseries?list=PL074BBF0BB0251DAD\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_b35ea40a409d7b31cec33583ce8de4b4%":"1470425214","%_oembed_33f17fc21d9dd43995f21c198e92911f%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/v1aRzOxfdXc?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_33f17fc21d9dd43995f21c198e92911f%":"1470425370","%_oembed_546fde702afcd848137e267784e3896a%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/FxsZ3JPFDHs?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_546fde702afcd848137e267784e3896a%":"1470425370","%_yoast_wpseo_focuskw_text_input%":"Blair School of Music","%_yoast_wpseo_focuskw%":"Blair School of Music","%_yoast_wpseo_title%":"Blair School of Music at Vanderbilt University","%_yoast_wpseo_metadesc%":"The Blair School of Music at Vanderbilt University is solely for undergraduates. The talented musicians we attract want conservatory-quality music training","%_yoast_wpseo_linkdex%":"62","%_oembed_4ac755eb05903915bcdc9a7b88d94810%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/v1aRzOxfdXc?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_4ac755eb05903915bcdc9a7b88d94810%":"1492836764","%_oembed_81bc9f70913401061429358dc9b23273%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/FxsZ3JPFDHs?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_81bc9f70913401061429358dc9b23273%":"1492836764","%ccft_post_comment_title%":"","%_oembed_fc3d5dc51a6e9cf52c0f9c41079b3dbd%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/eSwHge3ZUsA?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_fc3d5dc51a6e9cf52c0f9c41079b3dbd%":"1503607062","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"<a href=\"https:\/\/www.facebook.com\/Blair-School-of-Music-at-Vanderbilt-University-127848197295634\/?ref=search&__tn__=%2Cd%2CP-R&eid=ARAJyORpA3hAb0Wk_v7yFLd6XKDthj7SokQWa_wPeB4t-1AWxPVGnTrW0wygB52oIAO0byAAQo7cfv5q\" rel=\"noopener\" target=\"_blank\">https:\/\/www.facebook.com\/Blair-School-of-Music-at-Vanderbilt-University-127848197295634\/?ref=search&__tn__=%2Cd%2CP-R&eid=ARAJyORpA3hAb0Wk_v7yFLd6XKDthj7SokQWa_wPeB4t-1AWxPVGnTrW0wygB52oIAO0byAAQo7cfv5q<\/a>","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"<a href=\"https:\/\/twitter.com\/blairschool\" rel=\"noopener\" target=\"_blank\">https:\/\/twitter.com\/blairschool<\/a>","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_oembed_7b0cae0be94dcfb1b9e71498b4cf4f8c%":"<iframe title=\"Learn more about the Vanderbilt Blair School of Music.\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/p8Q4qQc48d8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_7b0cae0be94dcfb1b9e71498b4cf4f8c%":"1567713565","%_oembed_1b29d29188fb208c2eb0a3204c7676a1%":"<iframe title=\"International dream comes true for Blair composition major\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/t6GPA66zmUk?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_1b29d29188fb208c2eb0a3204c7676a1%":"1567713565","%_oembed_4602fc8c2701afa2390feee2217d6c26%":"<iframe title=\"Rama Kumaran goes off the beaten path to find his  musical vision\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/7vY3iLwbbyY?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_4602fc8c2701afa2390feee2217d6c26%":"1567713761","%_oembed_4de412abb1f47d44a2c53463c7f1ef4d%":"{{unknown}}","%_oembed_3072993498d5a98ed9daaf6d49991831%":"<a class=\"twitter-timeline\" data-width=\"500\" data-height=\"750\" data-dnt=\"true\" href=\"https:\/\/twitter.com\/blairschool?ref_src=twsrc%5Etfw\">Tweets by blairschool<\/a><script async src=\"https:\/\/platform.twitter.com\/widgets.js\" charset=\"utf-8\"><\/script>","%_oembed_time_3072993498d5a98ed9daaf6d49991831%":"1567714092","%_oembed_96a01b66d76b89591e98794a8eb9532d%":"{{unknown}}","%_oembed_594475ed7eb72266091e975c24a3ef88%":"<iframe title=\"Learn more about the Vanderbilt Blair School of Music.\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/p8Q4qQc48d8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_594475ed7eb72266091e975c24a3ef88%":"1567720126","%_oembed_73ec4982fde514c97598891e450f38db%":"<iframe title=\"International dream comes true for Blair composition major\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/t6GPA66zmUk?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_73ec4982fde514c97598891e450f38db%":"1567720126","%_oembed_2f934af895bf7a2ef565b668726e452e%":"<iframe title=\"Rama Kumaran goes off the beaten path to find his  musical vision\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/7vY3iLwbbyY?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_2f934af895bf7a2ef565b668726e452e%":"1567720126","%_oembed_825307dba5343f7b58211470f609eb54%":"<iframe title=\"Breakthrough Opportunities for a Vanderbilt Piano Phenom\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/eSwHge3ZUsA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_825307dba5343f7b58211470f609eb54%":"1567720127","%_thumbnail_id%":"25969","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_4394dd0d63008c3760757e1757714b21%":"<iframe title=\"An introduction to Vanderbilt University Blair School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Zsoywu5p5so?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_4394dd0d63008c3760757e1757714b21%":"1692231258","%_oembed_9fa947b702f1752d053c59413768133a%":"<iframe title=\"The Vanderbilt University Blair Big Band live at Jazz at Lincoln Center, performing &quot;Push and Pull&quot;\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/iuEC8HcoNIk?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_9fa947b702f1752d053c59413768133a%":"1692231258","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_2962c80a224ebf2f0f848f42c35801ea%":"<iframe title=\"An introduction to Vanderbilt University Blair School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Zsoywu5p5so?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_2962c80a224ebf2f0f848f42c35801ea%":"1701554023","%_oembed_2f1ccb15d95efdc9b9ca039c4de03931%":"<iframe title=\"The Vanderbilt University Blair Big Band live at Jazz at Lincoln Center, performing &quot;Push and Pull&quot;\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/iuEC8HcoNIk?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_2f1ccb15d95efdc9b9ca039c4de03931%":"1701554023","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_oembed_ce16be23890d93e1bde5ff6b00555dc9%":"<iframe title=\"Top music education: Vanderbilt Blair School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/OYlDWc9id0o?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_ce16be23890d93e1bde5ff6b00555dc9%":"1723661503","%_oembed_24fccc2804238b0c61b53979b459855d%":"{{unknown}}","%_oembed_ac47f21b6c2dd3b1f67956d302188873%":"{{unknown}}","%_oembed_94b9384dceed033a43320a31d1d6a713%":"{{unknown}}","%_oembed_fa59912db19c840cf6c60222684cf38f%":"{{unknown}}","%_oembed_9c390a939c83d900bd11e2442372d9af%":"{{unknown}}","%_oembed_5c2d49c411a4524810357b78de03e0e1%":"<iframe title=\"? Blair student feature: Meet flute performance major Abrielle Scott\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Ujs8mLhyzBc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_5c2d49c411a4524810357b78de03e0e1%":"1724352690","taxonomy=post_tag":"Blair School of Music, College of Music, major in music, majoring in music, Music colleges, music education, music major, music school, music students, School of Music, Vanderbilt University","taxonomy=schools_degrees":"Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Composition &amp; Theory, Performance - Instrumental, Performance - Vocal","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":14981,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"East Carolina University School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"East Carolina University School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/07\/eastcarolinanew-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/east-carolina-university-school-of-music\/\" class=\"fc-post-link\">East Carolina University School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"35.60007","lng":"-77.36335","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/east-carolina-university-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<strong>SEVEN REASONS TO ATTEND THE ECU SCHOOL OF MUSIC<\/strong>\r\n\r\n<strong>1. The Program You're Looking For<\/strong>\r\n\r\n<strong>Undergraduate (BM) Majors:<\/strong>\r\n\r\n\u2022 Music Education\r\n\u2022 Music Therapy\r\n\u2022 Performance (Jazz; Percussion; Piano; String; Vocal; Wind)\r\n\u2022 Music Theory - Composition\r\n\u2022 Sacred Music\r\n\r\n<strong>Master of Music (MM) Majors:<\/strong>\r\n\r\n\u2022 Collaborative piano\r\n\u2022 Conducting: Choral; Instrumental\r\n\u2022 Composition\r\n\u2022 Performance: Jazz; Percussion; Piano Strings; Vocal; Wind\r\n\u2022 Keyboard Performance (Specialist &amp; Pedagogy)\r\n\u2022 Music Education (pedagogy emphases 100% online)\r\n\u2022 Music History and Literature\r\n\u2022 Sacred Music\r\n\u2022 Theory\r\n\u2022 Vocal Pedagogy\r\n\u2022 Woodwind Specialist\r\n\r\n<strong>Advanced Performance Studies Certificate (CAPS)<\/strong>\r\n\r\n<strong>2. Strong Community<\/strong>\r\nThere is a distinct sense of community among the 250 undergraduate and 50 graduate students who spend most of each day under the roof of the A.J. Fletcher Music Center.\r\n\r\n<strong>3. Exceptional Faculty<\/strong>\r\nWith a 5-to-1 student-faculty ratio the School of Music faculty, leaders in their academic and professional fields, are intentionally accessible to their students.\r\n\r\n<strong>4. Intentional Diversity<\/strong>\r\nECU and the School of Music actively promote and celebrate the diversity of our university and School of Music communities.\r\n\r\n<strong>5. Outstanding University Education<\/strong>\r\nECU offers its students a superior liberal arts education, career services and quality-of-life resources.\r\n\r\n<strong>6. Excellent Value<\/strong>\r\nReceive an exceptional education with tuition and fees lower than many other schools.\r\n\r\n<strong>7. The Music Living Learning Community<\/strong>\r\nFreshmen music majors thrive in the Music LLC as they transition into college life supported by LLC programs, mentors and the ECU Campus Living staff. Together students experience the challenges and successes unique to their major while living in Gateway Residence Hall, the hub for ECU\u2019s Living Learning Communities.\r\n\r\nThe ECU School of Music offers academic excellence within a welcoming community. Come join us![\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=XZ3RSBVmlR8&amp;list=PL69CB3D225AB4DC20&amp;index=3\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/WvUOVTbp97g\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][vc_gallery type=\"image_grid\" images=\"24928,24927,24925,24924\" img_size=\"300x200\" onclick=\"\"][gravityform id=\"82\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"35.60007\" lng=\"-77.36335\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"East Carolina University School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/east-carolina-university-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"East Carolina University School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/07\/eastcarolinanew-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"East Carolina University School of Music, major in music, Music colleges, music degrees, music education, music major, music school, music students, School of Music","%easyindexInvalidate%":"1","%_edit_lock%":"1721095952:9","%_edit_last%":"9","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"35.60007","%_wpgmp_metabox_longitude%":"-77.36335","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"22618","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"24923","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Florida State University College of Music\" href=\"https:\/\/music.ecu.edu\/\" target=\"_blank\" rel=\"noopener\">School of Music Homepage<\/a><\/li>\r\n \t<li><a title=\"Florida State University College of Music\" href=\"https:\/\/music.ecu.edu\/bachelor-of-music-bm\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Majors<\/a><\/li>\r\n \t<li><a title=\"Florida State University College of Music\" href=\"https:\/\/music.ecu.edu\/about-us\/faculty-staff-information\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Florida State University College of Music\" href=\"https:\/\/music.ecu.edu\/ug-admission\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Applications &amp; Auditions<\/a><\/li>\r\n \t<li><a title=\"Florida State University College of Music\" href=\"https:\/\/financialaid.ecu.edu\/estimated-cost-of-attendance-coa\/\" target=\"_blank\" rel=\"noopener\">Tuition &amp; Fees<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.ecu.edu\/scholarships\/\" target=\"_blank\" rel=\"noopener\">Scholarships\/Financial Aid<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.ecu.edu\/caps\/\" target=\"_blank\" rel=\"noopener\">Advanced Performance Studies Certificate (CAPS)<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.ecu.edu\/master-of-music-mm-program\/\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.ecu.edu\/graduate-admissions\/\" target=\"_blank\" rel=\"noopener\">Graduate and CAPS Applications &amp; Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.ecu.edu\/summer\/\" target=\"_blank\" rel=\"noopener\">Summer Programs<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_oembed_4afca1e92d6d3724c975650dd46e0d74%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Z2DAabUvEk8?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_4afca1e92d6d3724c975650dd46e0d74%":"1468966251","%_oembed_9650019ae8fa5c95ac5c01e34037074e%":"<iframe width=\"500\" height=\"375\" src=\"https:\/\/www.youtube.com\/embed\/videoseries?list=PL69CB3D225AB4DC20\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_9650019ae8fa5c95ac5c01e34037074e%":"1468966251","%_thumbnail_id%":"25896","%_yoast_wpseo_focuskw_text_input%":"East Carolina University School of Music","%_yoast_wpseo_focuskw%":"East Carolina University School of Music","%_yoast_wpseo_title%":"East Carolina University School of Music - Music Major","%_yoast_wpseo_metadesc%":"The East Carolina University School of Music is one of the premier music schools in the Southeast with recognized and comprehensive music programs.","%_yoast_wpseo_linkdex%":"61","%_oembed_16bc90f7c1b4b992dd19654f5b22a901%":"<iframe width=\"500\" height=\"375\" src=\"https:\/\/www.youtube.com\/embed\/E-PJreOA2mY?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_16bc90f7c1b4b992dd19654f5b22a901%":"1468972473","%_oembed_05a66f75d30bc432de37550a3781e1cd%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Z2DAabUvEk8?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_05a66f75d30bc432de37550a3781e1cd%":"1468972537","%_oembed_c9fb65597df7695fed82cffbf370d686%":"<iframe width=\"500\" height=\"375\" src=\"https:\/\/www.youtube.com\/embed\/E-PJreOA2mY?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_c9fb65597df7695fed82cffbf370d686%":"1492885259","%_oembed_3c96994d778501a02d2d6f709b1cd489%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Z2DAabUvEk8?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_3c96994d778501a02d2d6f709b1cd489%":"1492885259","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_177d55dd3dc7e3a35b518d012d40deb5%":"{{unknown}}","%_oembed_4018dd817a1d218c568efbcc55ae598e%":"{{unknown}}","%_oembed_fabffb868d45666416656d42e6362f63%":"<iframe title=\"The Magnificent Seven | ECU Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/WvUOVTbp97g?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_fabffb868d45666416656d42e6362f63%":"1593726259","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_37a6ca0c2f2d36e02fe538171962f1b7%":"<iframe title=\"and the swallow by Caroline Shaw | ECU Chamber Singers\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/XZ3RSBVmlR8?list=PL69CB3D225AB4DC20\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_37a6ca0c2f2d36e02fe538171962f1b7%":"1688335308","%_oembed_71ae0db7f6e61ffd19b757ea6a0c207c%":"{{unknown}}","%_oembed_536193c432c82d8fcc8daf4169657a81%":"<iframe title=\"The Magnificent Seven | ECU Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/WvUOVTbp97g?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_536193c432c82d8fcc8daf4169657a81%":"1689276178","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_9034d3827fc0137596996d2a8cf8fba0%":"<iframe title=\"and the swallow by Caroline Shaw | ECU Chamber Singers\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/XZ3RSBVmlR8?list=PL69CB3D225AB4DC20\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_9034d3827fc0137596996d2a8cf8fba0%":"1701549954","%_oembed_ea5b8f201c85da183923782fad2cbfbb%":"<iframe title=\"The Magnificent Seven | ECU Symphony Orchestra\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/WvUOVTbp97g?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_ea5b8f201c85da183923782fad2cbfbb%":"1701549954","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"East Carolina University School of Music, major in music, Music colleges, music degrees, music education, music major, music school, music students, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Conducting, Music Education, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Sacred Music","taxonomy=schools_majors":"Composition &amp; Theory, Minor in music, Music Education, Music Therapy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Sacred Music","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":14816,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"The Eastman School of Music of the University of Rochester","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Eastman School of Music concert hall\" width=\"600\" height=\"391\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/07\/Eastman-School-of-Music-concert-hall-600x391.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/eastman-school-music-university-rochester\/\" class=\"fc-post-link\">The Eastman School of Music of the University of Rochester<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"43.15781","lng":"-77.60091","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/eastman-school-music-university-rochester\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\">An Eastman education forges the highest levels of artistry and scholarship with deep musicianship skills and entrepreneurial savvy. Eastman alumni are leaders in their respective disciplines, have created their own professional opportunities, and are shaping the future of music.<\/p>\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=JrgDpqb78Jc\" el_width=\"90\" align=\"center\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=L9ayML5xde0\" el_width=\"90\" align=\"center\"][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"19908,19912,19911,19907\" img_size=\"600x400\" onclick=\"\"][vc_raw_html]JTNDZGl2JTIwaWQlM0QlMjJtb3JlLWluZm9ybWF0aW9uJTIyJTNFJTNDJTJGZGl2JTNF[\/vc_raw_html][gravityform id=\"80\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"43.15781\" lng=\"-77.60091\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^13312|url^http:\/\/mim.americasfishtesting.com\/wp-content\/uploads\/2016\/05\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"The Eastman School of Music of the University of Rochester","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/eastman-school-music-university-rochester\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Eastman School of Music concert hall\" width=\"600\" height=\"391\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/07\/Eastman-School-of-Music-concert-hall-600x391.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, Eastman School of Music, major in music, majoring in music, music conservatory, music degrees, music education, music major, music schools, music students, School of Music, University of Rochester","%easyindexInvalidate%":"1","%_edit_lock%":"1718910788:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}.vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"43.15781","%_wpgmp_metabox_longitude%":"-77.60091","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"90","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"14760","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"19906","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li><a href=\"http:\/\/www.esm.rochester.edu\/admissions\" target=\"_blank\" rel=\"noopener\">Eastman Homepage<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.esm.rochester.edu\/admissions\/ugrad\/bm\/\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.esm.rochester.edu\/faculty\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.esm.rochester.edu\/admissions\/ugrad\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Applications<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.esm.rochester.edu\/admissions\/repertoire\/\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.esm.rochester.edu\/financialaid\/cost-of-attendance-undergraduate\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.esm.rochester.edu\/financialaid\/prospective\/#FAUG\" target=\"_blank\" rel=\"noopener\">Financial Aid<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.esm.rochester.edu\/equity\/\" target=\"_blank\" rel=\"noopener\">Equity and Inclusion<\/a><\/li>\r\n \t<li><a href=\"http:\/\/summer.esm.rochester.edu\/\" target=\"_blank\" rel=\"noopener\">Summer Music Program Summer @ Eastman<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.esm.rochester.edu\/admissions\/grad\/\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.esm.rochester.edu\/financialaid\/cost-of-attendance-graduate\/\" target=\"_blank\" rel=\"noopener\">Graduate Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/iml.esm.rochester.edu\/professional-development\/\" target=\"_blank\" rel=\"noopener\">Professional Development<\/a><\/li>\r\n \t<li><a href=\"https:\/\/apply.esm.rochester.edu\/register\/ebook\" target=\"_blank\" rel=\"noopener\">FREE E-Books: Applying and Auditioning for Music Schools<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_yoast_wpseo_focuskw_text_input%":"Eastman School of Music","%_yoast_wpseo_focuskw%":"Eastman School of Music","%_yoast_wpseo_title%":"The Eastman School of Music of the University of Rochester","%_yoast_wpseo_metadesc%":"An Eastman School of Music education forges the highest levels of artistry and scholarship with deep musicianship skills and entrepreneurial savvy.","%_yoast_wpseo_linkdex%":"47","%_oembed_b41375bc6672ac7eb7dd7b267d5cf8f2%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/An-CBQQpAMs?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_b41375bc6672ac7eb7dd7b267d5cf8f2%":"1469807766","%_oembed_41af8252fd50f8668b404bd9dfddd01c%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/tRZm08paTng?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_41af8252fd50f8668b404bd9dfddd01c%":"1469807766","%_oembed_6927c99c09a7c2edd265f61f1b4dbeeb%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/tRZm08paTng?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_6927c99c09a7c2edd265f61f1b4dbeeb%":"1492836764","%_oembed_656b89eccb37301ff64f8090b40064ad%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/An-CBQQpAMs?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_656b89eccb37301ff64f8090b40064ad%":"1492836764","%ccft_post_comment_title%":"","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"","%_oembed_97589fd26d5784b1bf21ec5e412c7155%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/F6zypEq04ME?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_97589fd26d5784b1bf21ec5e412c7155%":"1507218920","%_thumbnail_id%":"19905","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_primary_schools_graduateschools_majors%":"548","%_oembed_3f67859a6d28c9a973444c19da306ba9%":"<iframe title=\"What makes Eastman special?\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/F6zypEq04ME?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_3f67859a6d28c9a973444c19da306ba9%":"1567723531","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_oembed_aafbf9683f21a7a92c1679d7e0328b75%":"<iframe title=\"Eastman Virtual Tour\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/JrgDpqb78Jc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_aafbf9683f21a7a92c1679d7e0328b75%":"1627060244","%_oembed_4b56d99f3d4125acc3a294c8dfbf60b6%":"<iframe title=\"Eastman Centennial: Eastman Wind Ensemble\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/L9ayML5xde0?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_4b56d99f3d4125acc3a294c8dfbf60b6%":"1627060244","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_2c3295883b316507af95a162830fc9fe%":"<iframe title=\"Eastman Virtual Tour\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/JrgDpqb78Jc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_2c3295883b316507af95a162830fc9fe%":"1701547023","%_oembed_23ba9baff9022fc032d55f8d7abf4f50%":"<iframe title=\"Eastman Centennial: Eastman Wind Ensemble\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/L9ayML5xde0?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_23ba9baff9022fc032d55f8d7abf4f50%":"1701547024","%_monsterinsights_sitenote_active%":"0","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"College of Music, Eastman School of Music, major in music, majoring in music, music conservatory, music degrees, music education, music major, music schools, music students, School of Music, University of Rochester","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Conducting, Early Music\/ Historical Performance, Music Education, Opera - Directing, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Music Education, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":14749,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Florida State University College of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Florida State University College of Music\" width=\"600\" height=\"401\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/FLorida-State-music-opera-600x401.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/florida-state-university-college-music\/\" class=\"fc-post-link\">Florida State University College of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Florida State University College of Music","location":{"lat":"30.443094","lng":"-84.291845","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/florida-state-university-college-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]The Florida State University College of Music offers a comprehensive program of instruction for all students who seek to become professionals in music. Some <b>highlights <\/b>of the College of Music are:\r\n<ul>\r\n \t<li>11:1 faculty\/student ratio with over 90 full-time faculty<\/li>\r\n \t<li>750 undergraduate students, 400 graduate students (1150 maximum enrollment)<\/li>\r\n \t<li>3 mainstage operas every year<\/li>\r\n \t<li>Over 500 concerts each year with more than 40 ensembles to choose from<\/li>\r\n \t<li>FSU Music Theatre ranked in the top 10 programs represented on Broadway<\/li>\r\n \t<li>94% first-year retention rate<\/li>\r\n \t<li>15% of our undergraduates are pursuing a double major or dual degree<\/li>\r\n<\/ul>\r\nOur <b>faculty<\/b> are leaders in all areas of music, including:<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n<ul>\r\n \t<li>Music Performance (classical, jazz, and music theatre)<\/li>\r\n \t<li>Music Education<\/li>\r\n \t<li>Music Therapy<\/li>\r\n \t<li>Music Theory<\/li>\r\n \t<li>Music Composition<\/li>\r\n \t<li>Arts Administration<\/li>\r\n \t<li>Piano Technology<\/li>\r\n \t<li>Commercial Music<\/li>\r\n \t<li>Historical Musicology and Ethnomusicology<\/li>\r\n<\/ul>\r\nRecent faculty accomplishments include Grammy Awards, Pulitzer Prizes, and Guggenheim fellowships, as well as frequent performances in the United States and around the world.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\nOur <b>graduates<\/b> are leaders in their profession and have gone on to pursue successful careers as:<span class=\"Apple-converted-space\">\u00a0 \u00a0<\/span>\r\n<ul>\r\n \t<li>public school teachers<\/li>\r\n \t<li>professional performers<\/li>\r\n \t<li>conductors<\/li>\r\n \t<li>college and university professors<span class=\"Apple-converted-space\">\u00a0<\/span><\/li>\r\n \t<li>music therapists<\/li>\r\n \t<li>composers<\/li>\r\n \t<li>scholars<\/li>\r\n \t<li>administrators<\/li>\r\n \t<li>private music teachers<\/li>\r\n<\/ul>\r\nThe College now offers an <b>Entrepreneurship in Music<\/b> program, open to all students, that features:<b><span class=\"Apple-converted-space\">\u00a0<\/span><\/b>\r\n<ul>\r\n \t<li>entrepreneurship courses<\/li>\r\n \t<li>guest artist residencies focusing on entrepreneurial skills<\/li>\r\n \t<li>workshops to further enhance the student\u2019s education and better prepare our musicians for the professional world.<\/li>\r\n<\/ul>\r\nThe College of Music has <b>five fully-equipped recital spaces<\/b>, ranging in size from the recently renovated Ruby Diamond Concert Hall (1200 seats) to more intimate recital spaces. The College also boasts a large number of private practice rooms and dedicated rehearsal spaces for large ensembles.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\nOf particular interest to incoming freshmen is the <b>Music Living-Learning Center at Cawthon Hall<\/b>, a dormitory\/classroom space immediately adjacent to the College of Music. Open only to music majors and minors, Cawthon Hall includes its own practice rooms, a keyboard lab, and music classrooms, offering students numerous opportunities for musical enrichment from the comfort of their own residence hall.<span class=\"Apple-converted-space\">\u00a0<\/span>[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_gallery type=\"image_grid\" images=\"24028,24024,24025,24026\" img_size=\"600x400\" onclick=\"\"][vc_raw_html]JTNDZGl2JTIwaWQlM0QlMjJtb3JlLWluZm9ybWF0aW9uJTIyJTNFJTNDJTJGZGl2JTNF[\/vc_raw_html][gravityform id=\"73\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"30.443094\" lng=\"-84.291845\" zoom=\"12\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Florida State University College of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/florida-state-university-college-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Florida State University College of Music\" width=\"600\" height=\"401\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/FLorida-State-music-opera-600x401.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"college music, College of Music, Florida State, Florida State University, FSU, FSU College of Music, major in music, majoring in music, Music colleges, music degrees, music education, music major, music school, music schools, music students, School of Music","%_edit_lock%":"1720644200:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Florida State University College of Music","%_wpgmp_metabox_latitude%":"30.443094","%_wpgmp_metabox_longitude%":"-84.291845","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"25864","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"24022","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Florida State University College of Music\" href=\"https:\/\/music.fsu.edu\" target=\"_blank\" rel=\"noopener\">College of Music Homepage<\/a><\/li>\r\n \t<li><a title=\"Florida State University College of Music\" href=\"https:\/\/music.fsu.edu\/programs\/\" target=\"_blank\" rel=\"noopener\">Areas of Study<\/a><\/li>\r\n \t<li><a title=\"Florida State University College of Music\" href=\"https:\/\/music.fsu.edu\/study\/faculty-and-staff\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Florida State University College of Music\" href=\"https:\/\/music.fsu.edu\/study\/admissions\/\" target=\"_blank\" rel=\"noopener\">Applications &amp; Auditions<\/a><\/li>\r\n \t<li><a title=\"Florida State University College of Music\" href=\"https:\/\/controller.vpfa.fsu.edu\/student-business\/tuition-fees\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.fsu.edu\/study\/admissions\/scholarships\/\" target=\"_blank\" rel=\"noopener\">Scholarships<\/a><\/li>\r\n \t<li><a title=\"Florida State University College of Music\" href=\"https:\/\/music.fsu.edu\/events\/camps-festivals\/summer-music-camps\/\" target=\"_blank\" rel=\"noopener\">Summer Music Camps<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_thumbnail_id%":"24021","%_yoast_wpseo_focuskw_text_input%":"Florida State University College of Music","%_yoast_wpseo_focuskw%":"Florida State University College of Music","%_yoast_wpseo_title%":"Florida State University College of Music","%_yoast_wpseo_metadesc%":"The Florida State University College of Music offers a comprehensive program of instruction for all students who seek to become professionals in music. With","%_yoast_wpseo_linkdex%":"67","%category_sticky_post%":"0","%_yoast_wpseo_content_score%":"30","%ccft_post_comment_title%":"","%easyindexInvalidate%":"1","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"539","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","taxonomy=post_tag":"college music, College of Music, Florida State, Florida State University, FSU, FSU College of Music, major in music, majoring in music, Music colleges, music degrees, music education, music major, music school, music schools, music students, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Arts Management, Collaborative Piano, Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Composition &amp; Theory, Conducting, Ethnomusicology, Music Education, Music Therapy, Musicology, Opera - Directing, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Piano Technology","taxonomy=schools_majors":"Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Composition &amp; Theory, Minor in music, Music (B.A.), Music Education, Music Therapy, Musical Theatre, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Sacred Music","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":14344,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Walnut Hill School for the Arts","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Walnut Hill School for the Arts\" width=\"600\" height=\"405\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/walnuthill-600x405.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/walnut-hill-school-for-the-arts\/\" class=\"fc-post-link\">Walnut Hill School for the Arts<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Walnut Hill School for the Arts, Highland Street, Natick, MA, United States","location":{"lat":"42.2911663","lng":"-71.34632220000003","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/walnut-hill-school-for-the-arts\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\">Walnut Hill School for the Arts is an independent boarding and day high school offering a transformational educational experience purposefully designed for student artists in <strong>grades 9\u201312, and a postgraduate year<\/strong>.<\/p>\r\n<p style=\"font-weight: 400;\"><strong>Fast Facts<\/strong><\/p>\r\n\r\n<ul>\r\n \t<li style=\"font-weight: 400;\">291 students enrolled<\/li>\r\n \t<li style=\"font-weight: 400;\">34% international students;\u00a076% boarding students; 24% day students<\/li>\r\n \t<li style=\"font-weight: 400;\">The only high school program linking a\u00a0major conservatory (New England Conservatory - NEC) with an independent school.<\/li>\r\n \t<li style=\"font-weight: 400;\">Focus on classical instrumental, composition, jazz, or voice. Courses include chamber\u00a0music, composition, diction for singers, ear training, jazz,\u00a0music theory, solfege, and vocal training.<\/li>\r\n<\/ul>\r\nWe offer unparalleled training in dance; music; theater; visual art; and writing, film &amp; media arts, complemented by a robust and innovative academic curriculum. Every aspect of our program promotes our students\u2019 growth as bold artists, curious learners, and mindful citizens. Students from across the country and around the globe come together to form a dynamic community on our scenic campus located just west of Boston in Natick, Massachusetts.\r\n\r\n<strong>Walnut Hill offers:<\/strong>\r\n\r\n--Innovative performance projects,\r\n--Master classes by dynamic guest artists,\r\n--Contemporary topics like entrepreneurship and civic engagement,\r\n--Proximity to Boston and world-class concert halls and performances,\r\n--A community of like-minded artists\r\n\r\nOur program, offered within an inspiring creative community, <strong>prepares graduates to thrive in a conservatory, university, or college setting.<\/strong>\r\n<blockquote>\"Walnut Hill is a magical place for me. It is the most supportive community I know; it is a place that makes you believe that anything is possible. There are no judgments; there is only creativity, and more creativity. Knowing that 'one can do no wrong' is so empowering for a young artist, and for that I will forever be grateful to Walnut Hill.\"<\/blockquote>\r\n<p class=\"quote-citation\" style=\"padding-left: 20px;\">--- Gloria Chien '95, Steinway Artist since 2009<\/p>\r\n[\/vc_column_text][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"24556,24557,24558,24559\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"76\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"42.2911663\" lng=\"-71.34632220000003\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14277|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerYellow.png|caption^null|alt^null|title^markerYellow|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Walnut Hill School for the Arts","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/walnut-hill-school-for-the-arts\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Walnut Hill School for the Arts\" width=\"600\" height=\"405\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/walnuthill-600x405.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Arts High School, Arts High School for Music, music education, music high school, music school, music schools, School of Music, Walnut Hill, Walnut Hill School for the Arts","%_edit_lock%":"1730162397:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}.vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"Walnut Hill School for the Arts, Highland Street, Natick, MA, United States","%_wpgmp_metabox_latitude%":"42.2911663","%_wpgmp_metabox_longitude%":"-71.34632220000003","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"6\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Walnut Hill School for the Arts","%_yoast_wpseo_focuskw%":"Walnut Hill School for the Arts","%_yoast_wpseo_metadesc%":"Walnut Hill School for the Arts, located in Natick, MA, is a boarding and day school for students in grades 9-12. At Walnut Hill students receive expert...","%_yoast_wpseo_linkdex%":"59","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"15069","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"15070","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Walnut Hill music\" href=\"http:\/\/walnuthillarts.org\" target=\"_blank\" rel=\"noopener\">Homepage<\/a><\/li>\r\n \t<li><a title=\"Walnut Hill music\" href=\"https:\/\/www.walnuthillarts.org\/arts-high-school\/music\" target=\"_blank\" rel=\"noopener\">Music Programs Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.walnuthillarts.org\/admission\" target=\"_blank\" rel=\"noopener\">Admission<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.walnuthillarts.org\/admission\/audition-portfolio-review\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.walnuthillarts.org\/admission\/tuition\" target=\"_blank\" rel=\"noopener\">Tuition &amp; Financial Aid<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.walnuthillarts.org\/admission\/faqs\" target=\"_blank\" rel=\"noopener\">FAQs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.walnuthillarts.org\/arts-high-school\/music\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.walnuthillarts.org\/communityacademy\/summer-programs\" target=\"_blank\" rel=\"noopener\">Summer Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.facebook.com\/walnuthill\" target=\"_blank\" rel=\"noopener\"><img src=\"\/wp-content\/uploads\/2014\/07\/facebook-150x150.png\" alt=\"facebook\" width=\"35\" height=\"35\" \/><\/a>\u00a0<a href=\"http:\/\/instagram.com\/Walnuthillarts\" target=\"_blank\" rel=\"noopener\"><img src=\"\/wp-content\/uploads\/2014\/07\/instagram-150x150.png\" alt=\"instagram\" width=\"35\" height=\"35\" \/><\/a>\u00a0<a href=\"https:\/\/www.youtube.com\/user\/walnuthillschool\" target=\"_blank\" rel=\"noopener\"><img src=\"\/wp-content\/uploads\/2014\/07\/youtube-150x150.png\" alt=\"youtube\" width=\"35\" height=\"35\" \/><\/a>\u00a0<a href=\"https:\/\/twitter.com\/antonioviva\" target=\"_blank\" rel=\"noopener\"><img src=\"\/wp-content\/uploads\/2014\/07\/twitter-150x150.png\" alt=\"twitter\" width=\"35\" height=\"35\" \/><\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"347","%_oembed_529997e182c31f93001cada1b1b5f813%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/LR5HVEaciKk?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_529997e182c31f93001cada1b1b5f813%":"1464203031","%_oembed_68791f5b878dcea50669e3fe23560793%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/SHa59wzJVU4?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_68791f5b878dcea50669e3fe23560793%":"1464203031","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_title%":"Walnut Hill School for the Arts","%easyindexInvalidate%":"1","%_thumbnail_id%":"25906","%_oembed_dd9275d0b6d1bbcaadd4f69e4b3c4760%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/TJzTs77LtNc?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_dd9275d0b6d1bbcaadd4f69e4b3c4760%":"1471637637","%_oembed_3b788fe47f592d62388e7815a7395ade%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/LR5HVEaciKk?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_3b788fe47f592d62388e7815a7395ade%":"1492885627","%_oembed_f058376e38d2489741bff3f27b56192c%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/TJzTs77LtNc?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_f058376e38d2489741bff3f27b56192c%":"1492885627","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"Arts High School, Arts High School for Music, music education, music high school, music school, music schools, School of Music, Walnut Hill, Walnut Hill School for the Arts","taxonomy=schools_degrees":"","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"","taxonomy=schools_Region":"Arts High Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerYellow.png"},"id":13630,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerYellow.png","name":"Arts High Schools","id":"5","type":"category"}]},{"source":"post","title":"University of Toronto Faculty of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Toronto Faculty of Music\" width=\"600\" height=\"450\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/LeadImage-600x450.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-toronto-faculty-of-music\/\" class=\"fc-post-link\">University of Toronto Faculty of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"80 Queens Park, Toronto, ON M5S 2C5, Canada","location":{"lat":"43.66650799999999","lng":"-79.39447080000002","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-toronto-faculty-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\"><strong>The University of Toronto (U of T) is the largest university in Canada and is consistently ranked within the top 20 universities in the world.<\/strong><\/p>\r\nToronto is one of the<b> largest, safest, and most culturally diverse arts-oriented cities in the world<\/b>. It is home to numerous world-class performing arts ensembles and venues, and has rich traditions in many different musical styles.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\nU of T\u2019s <b>Faculty of Music<\/b> is recognized as Canada\u2019s leading institution for higher education in music, and is internationally renowned for academic and artistic excellence in music performance, education, composition, and research.<span class=\"Apple-converted-space\">\u00a0 <\/span>And yet, <b>tuition is considerably less <\/b>than at many American universities and music conservatories.\r\n\r\nOur diverse and experienced faculty members are among the finest in their fields. They perform on the world\u2019s most prestigious stages; they are scholars who present at leading international conferences and publish with top presses, educators who offer workshops and masterclasses worldwide, and composers whose works are commissioned by acclaimed musicians and arts organizations.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\nU of T Music brings together creative and motivated students with the outstanding educators. We offer programs in <b>performance (classical and jazz)<\/b>, <b>music education<\/b>, <b>composition<\/b>, <b>music history<\/b>, <b>theory<\/b>, and <b>culture, interdisciplinary music studies<\/b>, as well as courses that explore music\u2019s intersections with <b>health sciences<\/b>, <b>technology<\/b>, and <b>humanities<\/b>. The breadth and depth of our programs encourage students to explore new possibilities.\r\n\r\nStudents learn in small classes, build relationships with outstanding faculty and connect with other like-minded students. They experience a flexible and personalized educational experience in an environment that nurtures creativity and encourages students to achieve their best.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\nWith over 600 concerts, master classes, and symposia presented annually, U of T Music offers abundant opportunities to perform in solo, chamber music, and ensemble settings in both on and off-campus venues.\r\n\r\nWe hope you will make U of T Music the next destination on your musical journey.<span class=\"Apple-converted-space\">\u00a0<\/span>[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_separator border_width=\"10\"][vc_gallery type=\"image_grid\" images=\"25450,25447,25448,25449\" img_size=\"300x200\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"71\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"43.66650799999999\" lng=\"-79.39447080000002\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14278|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"University of Toronto Faculty of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-toronto-faculty-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Toronto Faculty of Music\" width=\"600\" height=\"450\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/LeadImage-600x450.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Canada music school, College of Music, majoring in music, Music colleges, music conservatory, music degree, music education, music major, music school, music schools, musical theatre, School of Music, Toronto music school, University of Toronto Faculty of Music","%_edit_lock%":"1730313430:4","%_edit_last%":"4","%_thumbnail_id%":"25445","%_wpb_vc_js_status%":"false","%_wpgmp_location_address%":"80 Queens Park, Toronto, ON M5S 2C5, Canada","%_wpgmp_metabox_latitude%":"43.66650799999999","%_wpgmp_metabox_longitude%":"-79.39447080000002","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"5\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"University of Toronto Faculty of Music","%_yoast_wpseo_focuskw%":"University of Toronto Faculty of Music","%_yoast_wpseo_metadesc%":"The University of Toronto Faculty of Music has long been a leader within Canada and is expanding its impact internationally through growth in its student population (currently 900).has long been a leader within Canada and is expanding its impact internationally through growth in its student population (currently 900).","%_yoast_wpseo_linkdex%":"63","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"12357","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"25446","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li><a href=\"https:\/\/music.utoronto.ca\/admissions\/undergraduate\/discover-music\/#anchor-explore-programs\" target=\"_blank\" rel=\"noopener\">Explore Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.utoronto.ca\/people\/faculty-instructors\" target=\"_blank\" rel=\"noopener\">Faculty &amp; Instructors<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.utoronto.ca\/admissions\/undergraduate\/apply-degree-programs\" target=\"_blank\" rel=\"noopener\">Applying<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.utoronto.ca\/admissions\/undergraduate\/audition-interview\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.utoronto.ca\/tuition-fees\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.utoronto.ca\/admissions\/undergraduate\/connect-with-admissions\" target=\"_blank\" rel=\"noopener\">Tours &amp; Visits<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"350","%_yoast_wpseo_content_score%":"30","%easyindexInvalidate%":"1","%ccft_post_comment_title%":"","%_oembed_c70b1122a51decec0a23b05f21cc1b0c%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/CVrYaHZRUhA?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_c70b1122a51decec0a23b05f21cc1b0c%":"1476743410","%_oembed_a4f3d95cc14971ced31de8b8c3831998%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/CVrYaHZRUhA?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_a4f3d95cc14971ced31de8b8c3831998%":"1492838018","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_141eb2a996168e0ecae23dbacdaa4ebe%":"<iframe title=\"Welcome To the University of Toronto\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/CVrYaHZRUhA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_141eb2a996168e0ecae23dbacdaa4ebe%":"1701545333","%_monsterinsights_sitenote_active%":"0","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"Canada music school, College of Music, majoring in music, Music colleges, music conservatory, music degree, music education, music major, music school, music schools, musical theatre, School of Music, Toronto music school, University of Toronto Faculty of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Conducting, Early Music\/ Historical Performance, Ethnomusicology, Music &amp; Health, Music Education, Music Technology, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Recording\/Production\/Engineering","taxonomy=schools_majors":"Composition &amp; Theory, Minor in music, Music Education, Musicology\/ Music History, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_Region":"International Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png"},"id":13628,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png","name":"International Music Schools","id":"4","type":"category"}]},{"source":"post","title":"University of South Carolina School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of South Carolina School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Univ-of-South-Carolina-trombone-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-south-carolina-school-of-music\/\" class=\"fc-post-link\">University of South Carolina School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"813 Assembly Street, Columbia, SC, United States","location":{"lat":"33.99542340000001","lng":"-81.03296710000001","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-south-carolina-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]\r\n<p class=\"intro\"><strong>The University of South Carolina\u2019s School of Music is nationally respected for professional musician career preparation and leadership in music teaching, performance, composition, industry, research and related fields, offering more than 20 degree programs including:<\/strong><\/p>\r\n\u2022 Performance\r\n\u2022 Music Teaching\r\n\u2022 Composition\r\n\u2022 Music Theory\r\n\u2022 Music Industry Studies\r\n\u2022 Music Leadership\r\n\u2022 Musical Theatre\r\n\u2022 Jazz Studies\r\n\u2022 Music Entrepreneurship\r\n\u2022 Audio Recording\r\n\u2022 Music Teaching Artist Certificate (MTAC)\r\n\r\nBeyond sought-after academics, the school is nationally recognized for its <strong>music education models, learning centers and community engagement programs<\/strong>. Students can grow as performers and future professionals in the school\u2019s extensive range of performance venues \u2014 including the renowned Koger Center for the Arts \u2014 which host more than 300 concerts and recitals each year.\r\n\r\nThe School of Music is peer-evaluated to be among the most highly regarded music schools and conservatories in the United States and is accredited by the National Association of Schools of Music. Among all of the School\u2019s degree programs, its <strong>community engagement initiatives, graduate piano pedagogy, and doctoral programs in choral conducting, wind conducting and orchestral conducting<\/strong> are recognized at the national level.\r\n\r\nThe School of Music is home to <strong>Spark, the nation\u2019s most comprehensive entity for the study of music leadership.<\/strong> The program, which prioritizes health and wellness for all music students, faculty and staff, supplements a traditional music school experience by preparing musicians for vibrant, sustainable futures. The program mixes coursework, project support, guest residencies, advocacy, entrepreneurship, community engagement instruction and other initiatives to foster an unparalleled environment of creative learning, skill development, collaboration and personal exploration.\r\n\r\nIn addition to the School of Music\u2019s frequent student and faculty ensembles, the <strong>ASCAP-award-winning Southern Exposure New Music Series<\/strong> features notable guest artists and university students and faculty. Every semester, the Grammy Award-winning Parker Quartet Residency offers public concerts and community engagement events as well as master classes where students learn directly from professional performers. Each summer, the Southeastern Piano Festival draws local audiences and gifted young pianists from around the world to compete in the Arthur Fraser International Piano Competition.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_video link=\"https:\/\/www.youtube.com\/watch?v=fDe-uAYS1yc\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"24963,24966,24965,24964\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"62\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"33.99542340000001\" lng=\"-81.03296710000001\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14281|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png|caption^null|alt^null|title^markerGreen|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"University of South Carolina School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-south-carolina-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of South Carolina School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Univ-of-South-Carolina-trombone-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, major in music, majoring in music, music education, music schools, music students, School of Music, University of South Carolina School of Music","%_edit_lock%":"1731106346:4","%_edit_last%":"4","%_thumbnail_id%":"24961","%_wpb_vc_js_status%":"false","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"813 Assembly Street, Columbia, SC, United States","%_wpgmp_metabox_latitude%":"33.99542340000001","%_wpgmp_metabox_longitude%":"-81.03296710000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"university of south carolina school of music","%_yoast_wpseo_focuskw%":"university of south carolina school of music","%_yoast_wpseo_metadesc%":"The University of South Carolina School of Music has established a national reputation for artistic and scholarly excellence and is among the most highly...","%_yoast_wpseo_linkdex%":"61","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"24938","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"24960","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"http:\/\/www.sc.edu\/study\/colleges_schools\/music\/index.php\" target=\"_blank\" rel=\"noopener\">School of Music Homepage<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.sc.edu\/study\/colleges_schools\/music\/study\/degree_programs\/index.php\" target=\"_blank\" rel=\"noopener\">Degrees\/Majors<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.sc.edu\/study\/colleges_schools\/music\/faculty-staff\/index.php\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.sc.edu\/study\/colleges_schools\/music\/apply\/index.php\" target=\"_blank\" rel=\"noopener\">Apply<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.sc.edu\/study\/colleges_schools\/music\/apply\/undergraduate_admissions\/undergraduate_auditions\/index.php\" target=\"_blank\" rel=\"noopener\">Audition-Undergraduate<\/a><\/li>\r\n \t<li><a href=\"https:\/\/sc.edu\/about\/offices_and_divisions\/financial_aid\/cost_and_aid\/cost_to_attend\/index.php\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.sc.edu\/study\/colleges_schools\/music\/apply\/undergraduate_admissions\/scholarships_financial_aid_music.php\" target=\"_blank\" rel=\"noopener\">Music Scholarships<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.sc.edu\/study\/colleges_schools\/music\/community\/summer_programs\/index.php\" target=\"_blank\" rel=\"noopener\">Summer Programs<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.sc.edu\/study\/colleges_schools\/music\/apply\/graduate_admissions\/index.php\" target=\"_blank\" rel=\"noopener\">Graduate Admissions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.sc.edu\/study\/colleges_schools\/music\/spark_laboratory\/index.php\" target=\"_blank\" rel=\"noopener\">Spark Music Leadership Laboratory<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.sc.edu\/study\/colleges_schools\/music\/alumni\/index.php\" target=\"_blank\" rel=\"noopener\">Alumni Spotlights<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_oembed_7671bee55c943e0b32234cc4696e750e%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/-gEZ0YAOQms?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_7671bee55c943e0b32234cc4696e750e%":"1464200381","%_oembed_d6e794c4932cd3688725efab4678d7af%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ZNvyD8WNfCg?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_d6e794c4932cd3688725efab4678d7af%":"1464200381","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_title%":"University of South Carolina School of Music","%easyindexInvalidate%":"1","%_oembed_dbd49987d4780c9c529c8d36ea8a636c%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/-gEZ0YAOQms?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_dbd49987d4780c9c529c8d36ea8a636c%":"1492840305","%_oembed_93f5cffaaed4fe77bb24ee99fd3bc2fb%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ZNvyD8WNfCg?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_93f5cffaaed4fe77bb24ee99fd3bc2fb%":"1492840305","%ccft_post_comment_title%":"","%_oembed_8f2a1b10f3246ffeb84ab73ac73fb909%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/AeooCXRrnrU?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_8f2a1b10f3246ffeb84ab73ac73fb909%":"1520445832","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"579","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_32edc87b576023940c7dee2f01719bad%":"<iframe title=\"Bernstein MASS\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/AeooCXRrnrU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_32edc87b576023940c7dee2f01719bad%":"1567723531","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_aa1d5745acd6b586e9daa2104534b83a%":"<iframe title=\"Consider yourself challenged - The University of South Carolina School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/fDe-uAYS1yc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_aa1d5745acd6b586e9daa2104534b83a%":"1657823055","%_oembed_3d4794f5d82706fc305eb39102844502%":"<iframe title=\"220423 New Voices: Music by UofSC Student Composers\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/pALNF3IQgQk?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_3d4794f5d82706fc305eb39102844502%":"1657823055","%_oembed_23f066fb534849658f1bf27af1fe16fa%":"<iframe title=\"Carmina Burana, April 2023\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/q8_p6L8_gRg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_23f066fb534849658f1bf27af1fe16fa%":"1688774294","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_30d05ddb72ee9bc171155f377729cbd3%":"<iframe title=\"Consider yourself challenged - The University of South Carolina School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/fDe-uAYS1yc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_30d05ddb72ee9bc171155f377729cbd3%":"1701549660","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"College of Music, major in music, majoring in music, music education, music schools, music students, School of Music, University of South Carolina School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Composition &amp; Theory, Conducting, Music Education, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_majors":"Chamber Music, Composition &amp; Theory, Minor in music, Music (B.A.), Music Education, Music Technology, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":13620,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"USC Thornton School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"USC Thornton School of Music\" width=\"600\" height=\"450\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/USC-Campus-600x450.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/usc-thornton-school-of-music\/\" class=\"fc-post-link\">USC Thornton School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"840 West 34th Street, Los Angeles, CA 90089, United States","location":{"lat":"34.023082","lng":"-118.28492590000002","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/usc-thornton-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<h3>At the USC Thornton School of Music, we celebrate our location in Los Angeles, the nation\u2019s center for creativity and innovation.<\/h3>\r\nAs the music profession changes, the USC Thornton School of Music offers an innovative education that prepares students for careers at the highest level as performers, composers, educators and industry leaders.\r\n\r\n<b>Our three exceptional divisions offer cross-genre experiences unique among the country\u2019s top music schools.<\/b>\u00a0As a leading international research institution, USC offers students a rigorous, global education that enriches their artistic and musical development.\r\n\r\nOur\u00a0<b>Classical Performance and Composition Division\u2019s<\/b>\u00a0curriculum challenges students to develop a distinct artistic voice and create a thriving life and career in music. Our goal? To train artists who will expand classical music\u2019s influence and impact, now and in years to come.\r\n\r\nPrograms in the\u00a0<b>Division of Contemporary Music<\/b>\u00a0are among the industry\u2019s best and most celebrated. Known for their embrace of new technology and creative collaborations with new media, dance, theater and musicians located around the world, our faculty and students have always been musical trailblazers.\r\n\r\nUSC Thornton integrates all aspects of musical reflection in our\u00a0<b>Research and Scholarly Studies Division<\/b>\u00a0coursework, from research and pedagogy to innovative strategies of arts leadership. Alumni are working on and off the stage \u2013 in higher education and K-12 classrooms, archives, studios, leadership positions, and more.\r\n\r\n<i>\u201cI was able to broaden the scope of what I was studying at Thornton. I was really surprised by the kinds of skills I was able to acquire, things I didn\u2019t think I\u2019d be working on when I entered.\u201d \u2013 Adam Karelin (BM \u201922, MS \u201923) USC\u2019s 2022 Valedictorian who earned a BM in Composition with a minor in Linguistics, and a MS in Arts Leadership.<\/i>\r\n\r\nVisit our website for information regarding application and audition requirements, faculty, events, alumni spotlights, and more!\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=DmdClLLVTMs\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=eRFbqTLjXqU&amp;t=34s\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"19891,19892\" img_size=\"600x400\" onclick=\"\"][vc_gallery type=\"image_grid\" images=\"19893,19894\" img_size=\"900x600\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"2\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"34.023082\" lng=\"-118.28492590000002\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14280|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png|caption^null|alt^null|title^markerOrange|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"USC Thornton School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/usc-thornton-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"USC Thornton School of Music\" width=\"600\" height=\"450\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/USC-Campus-600x450.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, jazz, major in music, majoring in music, music education, music industry, music school, music schools, music students, musical theatre, popular music, School of Music, singer-songwriter, University of Southern California","%_edit_lock%":"1727896461:4","%_edit_last%":"4","%_wpb_vc_js_status%":"false","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"840 West 34th Street, Los Angeles, CA 90089, United States","%_wpgmp_metabox_latitude%":"34.023082","%_wpgmp_metabox_longitude%":"-118.28492590000002","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"4\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"usc thornton school of music","%_yoast_wpseo_focuskw%":"usc thornton school of music","%_yoast_wpseo_metadesc%":"USC Thornton School of Music (University of Southern California) is a global destination for those who are serious about music. Located in Los Angeles, our mission is to reflect L.A.'s unique and eclectic artistic landscape.","%_yoast_wpseo_linkdex%":"69","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"12464","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"19897","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li><a title=\"USC Thornton School of Music\" href=\"http:\/\/music.usc.edu\" target=\"_blank\" rel=\"noopener\">Homepage<\/a><\/li>\r\n \t<li><a title=\"USC Thornton School of Music\" href=\"http:\/\/music.usc.edu\/departments\/\" target=\"_blank\" rel=\"noopener\">Degrees and Programs<\/a><\/li>\r\n \t<li><a title=\"USC Thornton School of Music faculty\" href=\"http:\/\/music.usc.edu\/faculty\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"USC Thornton School of Music admission\" href=\"http:\/\/music.usc.edu\/admission\/\" target=\"_blank\" rel=\"noopener\">How to Apply<\/a><\/li>\r\n \t<li><a title=\"USC Thornton School of Music\" href=\"http:\/\/music.usc.edu\/admission\/finaid\/\" target=\"_blank\" rel=\"noopener\">Tuition &amp; Financial Aid Information<\/a><\/li>\r\n \t<li><a title=\"USC Thornton School of Music\" href=\"https:\/\/music.usc.edu\/viewbook\/\" target=\"_blank\" rel=\"noopener\">USC Thornton Viewbook<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.usc.edu\/admission\/student-ambassadors\/\" target=\"_blank\" rel=\"noopener\">Student Ambassadors<\/a><\/li>\r\n \t<li><a title=\"USC Thornton School of Music alumni\" href=\"https:\/\/music.usc.edu\/alumni\/accomplishments\/\" target=\"_blank\" rel=\"noopener\">Alumni Accomplishments<\/a><\/li>\r\n \t<li><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>\r\n&nbsp;\r\n<ul>\r\n \t<li>\u00a0\u00a0<a href=\"https:\/\/www.facebook.com\/uscthornton\" target=\"_blank\" rel=\"noopener\"><img src=\"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2014\/07\/facebook-150x150.png\" alt=\"facebook\" width=\"36\" height=\"36\" \/><\/a>\u00a0<a href=\"https:\/\/instagram.com\/uscthornton\/\" target=\"_blank\" rel=\"noopener\"><img src=\"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2014\/07\/instagram-150x150.png\" alt=\"instagram\" width=\"36\" height=\"36\" \/><\/a>\u00a0<a href=\"https:\/\/twitter.com\/USCThornton\" target=\"_blank\" rel=\"noopener\"><img src=\"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2014\/07\/twitter-150x150.png\" alt=\"twitter\" width=\"36\" height=\"36\" \/><\/a>\u00a0<a href=\"https:\/\/www.youtube.com\/user\/USCThornton\" target=\"_blank\" rel=\"noopener\"><img src=\"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2014\/07\/youtube-150x150.png\" alt=\"youtube\" width=\"36\" height=\"36\" \/><\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"351","%_oembed_c9cc4bf50c83b199beb96eca7deccb91%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/SW9TSV_InTw?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_c9cc4bf50c83b199beb96eca7deccb91%":"1464199799","%_oembed_9ac6cdd969d604783b64b5eb903b266e%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/R1OzjoJbuKs?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_9ac6cdd969d604783b64b5eb903b266e%":"1464199799","%_yoast_wpseo_content_score%":"60","%ccft_post_comment_title%":"","%easyindexInvalidate%":"1","%_oembed_557a62674ec45514c364160f4ddc0c8f%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/SW9TSV_InTw?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_557a62674ec45514c364160f4ddc0c8f%":"1492848947","%_oembed_50328fd84bab58153130b199ff42b7f9%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/R1OzjoJbuKs?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_50328fd84bab58153130b199ff42b7f9%":"1492848947","%_oembed_8e6b5d01d9723b645c2a0b84b80495c7%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/F8hhsAmkDgU?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_8e6b5d01d9723b645c2a0b84b80495c7%":"1517349348","%_oembed_0b12dde3f62678871d596cd6360c9467%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ZZLC3jQAwSM?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_0b12dde3f62678871d596cd6360c9467%":"1517349349","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"483","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_13a382acce35d738b905f61bf03cc84e%":"<iframe title=\"Welcome to USC Thornton\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/F8hhsAmkDgU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_13a382acce35d738b905f61bf03cc84e%":"1564949848","%_oembed_1326c1890f94d10651c816da4c5e3eb4%":"<iframe title=\"The New Classical | USC Thornton\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/yp40mj6qOGI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_1326c1890f94d10651c816da4c5e3eb4%":"1564949848","%_oembed_08f7df03295aaf91f6809f2124705011%":"<iframe title=\"Welcome to USC Thornton\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/F8hhsAmkDgU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_08f7df03295aaf91f6809f2124705011%":"1567720869","%_oembed_9d2a32801a1d24a5d4e941e9381102af%":"<iframe title=\"The New Classical | USC Thornton\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/yp40mj6qOGI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_9d2a32801a1d24a5d4e941e9381102af%":"1567720869","%_oembed_2654d4f1e6a21a7b63fd568f74960fca%":"<iframe title=\"USC Thornton Snapshot: A Look Inside the USC Thornton School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/bAFfnlPLACI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_2654d4f1e6a21a7b63fd568f74960fca%":"1604338854","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_64258927f00ebbc6a94615804f7fba81%":"{{unknown}}","%_oembed_bc5940384ba827f45d81d9448e5c5a10%":"{{unknown}}","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_oembed_9951458368ca1ba3b1cc8d1c7c7f30c8%":"<iframe title=\"Discover USC Thornton\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/DmdClLLVTMs?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_9951458368ca1ba3b1cc8d1c7c7f30c8%":"1724784571","%_oembed_74dd4f57fb2893d1e40ac819e2f672c1%":"<iframe title=\"USC Thornton Campus Snapshot: A Look Inside the USC Thornton School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/eRFbqTLjXqU?start=34&feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_74dd4f57fb2893d1e40ac819e2f672c1%":"1724784622","%_thumbnail_id%":"26126","taxonomy=post_tag":"College of Music, jazz, major in music, majoring in music, music education, music industry, music school, music schools, music students, musical theatre, popular music, School of Music, singer-songwriter, University of Southern California","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Arts Management, Collaborative Piano, Composition &amp; Theory, Early Music\/ Historical Performance, Music Education, Music Industry, Musicology, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Sacred Music, Scoring","taxonomy=schools_majors":"Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Composition &amp; Theory, Minor in music, Music Business, Music Industry, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Western US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png"},"id":13617,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png","name":"Western US Music Schools","id":"3","type":"category"}]},{"source":"post","title":"University of Houston Moores School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Houston Moores School of Music\" width=\"600\" height=\"513\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/houstonnew-600x513.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-houston-moores-school-of-music\/\" class=\"fc-post-link\">University of Houston Moores School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","location":{"lat":"29.7251621","lng":"-95.3467647","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-houston-moores-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n\r\n<span style=\"font-size: 14pt;\"><strong>The University of Houston\u2019s Moores School of Music\u2019s commitment to academic excellence and the highest performance standards makes the institution a vital resource in the educational and cultural life of Houston. With its stellar faculty, the School remains at the forefront of university-level music education today.<\/strong><\/span>\r\n\r\nThe Moores School of Music is distinguished by an impressive list of achievements and accolades. The Concert Chorale and Percussion Ensemble have both won multiple international competitions, the Moores Opera Center is one of the largest opera training programs in the nation and the Symphony Orchestra and Wind Ensemble have each released numerous highly acclaimed commercial recordings. From the contemporary music ensemble, AURA, creating multidisciplinary collaborations, to the 95% job placement rate of our Music Education students, the Moores School of Music\u2019s record of excellence continues to draw students from all over the world.\r\n\r\nAny out-of-state student who earns a University of Houston Academic Scholarship, OR a Moores School of Music Scholarship of $1000 or more will automatically qualify for the in-state tuition rate.\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_video link=\"http:\/\/www.youtube.com\/watch?v=xsq73yn_5fw\"][vc_column_text]\r\n<p class=\"caption\">University of Houston's Edythe Bates Old Moores Opera House is home to one of the top-ranked university opera programs in the United States.<\/p>\r\n[\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"25141,25140,25142,25143\" img_size=\"300x200\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"47\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"29.7251621\" lng=\"-95.3467647\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14276|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png|caption^null|alt^null|title^markerPurpleNew|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"University of Houston Moores School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-houston-moores-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Houston Moores School of Music\" width=\"600\" height=\"513\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/houstonnew-600x513.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, Moores School of Music, music school, music schools, School of Music, University of Houston","%_edit_lock%":"1722634609:4","%_edit_last%":"4","%_thumbnail_id%":"25905","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"","%_wpgmp_metabox_latitude%":"29.7251621","%_wpgmp_metabox_longitude%":"-95.3467647","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Moores School of Music","%_yoast_wpseo_focuskw%":"Moores School of Music","%_yoast_wpseo_metadesc%":"The Moores School of Music's commitment to academic and musical excellence has made the institution a vital resource in the educational and cultural life of the city of Houston.","%_yoast_wpseo_linkdex%":"57","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"25144","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"25139","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Moores School of Music\" href=\"https:\/\/www.uh.edu\/kgmca\/music\/\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a title=\"Moores School of Music\" href=\"https:\/\/uh.edu\/kgmca\/music\/academics\/\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a title=\"Moores School of Music\" href=\"https:\/\/www.uh.edu\/kgmca\/music\/about-us\/faculty-staff\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Moores School of Music\" href=\"https:\/\/www.uh.edu\/kgmca\/music\/admissions\/undergraduate-admission\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Applications<\/a><\/li>\r\n \t<li><a title=\"Moores School of Music\" href=\"https:\/\/uh.edu\/kgmca\/music\/admissions\/undergraduate-admission\/undergrad-audition-requirements-2023.pdf\" target=\"_blank\" rel=\"noopener\">Undergraduate Audition Specifics<\/a><\/li>\r\n \t<li><a title=\"Moores School of Music\" href=\"https:\/\/uh.edu\/kgmca\/music\/admissions\/graduate-admissions\/\" target=\"_blank\" rel=\"noopener\">Graduate Admissions &amp; Audition Specifics<\/a><\/li>\r\n \t<li><a href=\"https:\/\/uh.edu\/undergraduate-admissions\/cost\/\" target=\"_blank\" rel=\"noopener\">Cost of Attendance &amp; Scholarships<\/a><\/li>\r\n \t<li><a title=\"Moores School of Music\" href=\"https:\/\/www.uh.edu\/kgmca\/music\/events\/festivals\/\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"348","%_oembed_79e5fe46d9a6c58c2b933c2f184117b3%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/xsq73yn_5fw?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_79e5fe46d9a6c58c2b933c2f184117b3%":"1464194692","%_yoast_wpseo_content_score%":"60","%_wp_old_slug%":"moores-school-of-music","%easyindexInvalidate%":"1","%_oembed_b731c1ffcf349e1f1806ad993cb99402%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/xsq73yn_5fw?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_b731c1ffcf349e1f1806ad993cb99402%":"1492846180","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"481","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_5c038895edf6b6f99d088f6a2ad26a31%":"<iframe title=\"UH Moment: With Renovations Complete, Moores Opera House Shines\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/xsq73yn_5fw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_5c038895edf6b6f99d088f6a2ad26a31%":"1701549461","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"College of Music, Moores School of Music, music school, music schools, School of Music, University of Houston","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Conducting, Music Education, Musicology, Pedagogy, Performance - Instrumental, Performance - Vocal, Sacred Music","taxonomy=schools_majors":"Arts Management, Composition &amp; Theory, Music (B.A.), Music Business, Music Education, Performance - Instrumental, Performance - Vocal, Sacred Music","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":13608,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"University of Denver Lamont School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Denver Lamont School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Lamont-School-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-denver-lamont-school-of-music\/\" class=\"fc-post-link\">University of Denver Lamont School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"2344 E Iliff Ave, Denver, CO 80210, United States","location":{"lat":"39.6746076","lng":"-104.96007739999999","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-denver-lamont-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]\r\n<p class=\"intro\"><strong>The\u202fLamont School of Music\u202fat the University of Denver is a premier music school within a top research university located in a vibrant arts city.<\/strong><\/p>\r\nLamont is committed to providing\u00a0<b>excellent, innovative musical training<\/b>\u00a0and the skills and experiences necessary to <b>Perform at Your Peak<\/b> as a modern musician. We provide students a multi-genre curriculum in\u00a0<b>performance, scholarship and entrepreneurship<\/b>, developing artist-citizens committed to the public good.\r\n\r\nWe are a part of the\u00a0<b>University of Denver<\/b>, long respected for its academic excellence and broad range of programs. <b>The Rocky Mountain Region\u00a0<\/b>is home to some of the nation\u2019s premiere performance venues including Red Rocks Amphitheater and the Denver Center for the Performing Arts.\r\n\r\n<b>Undergraduate Programs:<\/b>\r\n<ul>\r\n \t<li>Bachelor of Music in Performance<\/li>\r\n \t<li>Bachelor of Music in Jazz Studies<\/li>\r\n \t<li>Bachelor of Music in Composition<\/li>\r\n \t<li>Bachelor of Music in Recording and Production<\/li>\r\n \t<li>Bachelor of Arts in Applied Music<\/li>\r\n \t<li>Minor in Music<\/li>\r\n \t<li>Minor in Ethnomusicology<\/li>\r\n<\/ul>\r\n<b>Graduate Programs:<\/b>\r\n<ul>\r\n \t<li>Master of Music in Performance<\/li>\r\n \t<li>Master of Music in Conducting<\/li>\r\n \t<li>Master of Music in Composition<\/li>\r\n \t<li>Master of Music in Suzuki Pedagogy<\/li>\r\n \t<li>Master of Arts in Music Theory<\/li>\r\n \t<li>Master of Arts in Musicology<\/li>\r\n \t<li><b>Artist Diplomas<\/b> in both Performance and Conducting<\/li>\r\n \t<li><b>Certificates<\/b> in: Performance; Conducting; Jazz Studies; Music Entrepreneurship; Music Theory Pedagogy; Orchestral Studies; Piano Pedagogy; Suzuki Pedagogy. Online Certificates in Performance and Composition; Performance and Orchestra Audition Preparation; Performance and Recording &amp; Production.<\/li>\r\n<\/ul>\r\n<b>Fast Facts:<\/b>\r\n<ul>\r\n \t<li>6:1 student-to-faculty ratio<\/li>\r\n \t<li>300+ performances a year<\/li>\r\n \t<li>300 music majors (13,000 total students at DU)<\/li>\r\n \t<li>25 large and small ensembles<\/li>\r\n \t<li>Double major opportunities<\/li>\r\n \t<li>National leader in <b>study abroad programs<\/b> with flights, visa fees, and differences in tuition covered for hundreds of institutions world-wide<\/li>\r\n \t<li>Faculty and alumni perform with celebrated ensembles, including the Colorado Symphony, Denver Brass, Central City Opera, Opera Colorado, Aspen Music Festival, Bravo! Vail Music Festival, and the Jazz Repertory Orchestra, among others.<\/li>\r\n<\/ul>\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/embed\/U8Mvtp5DYbw\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/embed\/c0GnrKcrFZg\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1504127270883{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"24997,24999,24998,25000\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"50\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"39.6746076\" lng=\"-104.96007739999999\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14280|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png|caption^null|alt^null|title^markerOrange|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"University of Denver Lamont School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-denver-lamont-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Denver Lamont School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Lamont-School-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, major in music, music education, music school, music students, School of Music","%_edit_lock%":"1720724826:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"2344 E Iliff Ave, Denver, CO 80210, United States","%_wpgmp_metabox_latitude%":"39.6746076","%_wpgmp_metabox_longitude%":"-104.96007739999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"4\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Lamont School of Music","%_yoast_wpseo_focuskw%":"Lamont School of Music","%_yoast_wpseo_metadesc%":"The Lamont School of Music at the University of Denver is widely recognized as a premier university music school with a long-standing tradition of excellence.","%_yoast_wpseo_linkdex%":"61","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"25003","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"24996","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Lamont School of Music\" href=\"https:\/\/liberalarts.du.edu\/lamont\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a title=\"Lamont School of Music\" href=\"https:\/\/liberalarts.du.edu\/lamont\/academics\/undergraduate-programs\" target=\"_blank\" rel=\"noopener\">Undergraduate Programs<\/a><\/li>\r\n \t<li><a title=\"Lamont School of Music\" href=\"https:\/\/liberalarts.du.edu\/lamont\/faculty-staff\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Lamont School of Music\" href=\"https:\/\/liberalarts.du.edu\/lamont\/admission-aid\" target=\"_blank\" rel=\"noopener\">Applications<\/a><\/li>\r\n \t<li><a title=\"Lamont School of Music\" href=\"https:\/\/liberalarts.du.edu\/lamont\/academics\/studios\" target=\"_blank\" rel=\"noopener\">Audition Specifics<\/a><\/li>\r\n \t<li><a title=\"Lamont School of Music\" href=\"https:\/\/www.du.edu\/admission-aid\/financial-aid-scholarships\/undergraduate-financial-aid\/price-and-affordability\/cost-attendance\" target=\"_blank\" rel=\"noopener\">Undergraduate Cost of Attendance<\/a><\/li>\r\n \t<li><a title=\"Lamont School of Music\" href=\"https:\/\/liberalarts.du.edu\/lamont\/admission-aid\/financial-aid#undergraduate\" target=\"_blank\" rel=\"noopener\">Undergraduate Financial Aid<\/a><\/li>\r\n \t<li><a title=\"Lamont School of Music\" href=\"https:\/\/liberalarts.du.edu\/lamont\/academics\/graduate-programs\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.du.edu\/admission-aid\/financial-aid-scholarships\/graduate-cost-attendance\" target=\"_blank\" rel=\"noopener\">Graduate Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/liberalarts.du.edu\/lamont\/admission-aid\/financial-aid#graduate\">Graduate Financial Aid<\/a><\/li>\r\n \t<li><a title=\"Lamont School of Music\" href=\"https:\/\/liberalarts.du.edu\/lamont\/summer-academy\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n \t<li><a title=\"Lamont School of Music\" href=\"https:\/\/liberalarts.du.edu\/lamont\/newsletter\" target=\"_blank\" rel=\"noopener\">Alumni Profiles<\/a><\/li>\r\n \t<li><a href=\"https:\/\/liberalarts.du.edu\/lamont\/news-events\/all-articles\/lamont-career-resources\" target=\"_blank\" rel=\"noopener\">Lamont Career Resources<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"351","%_yoast_wpseo_content_score%":"60","%_wp_old_slug%":"lamont-school-of-music","%easyindexInvalidate%":"1","%ccft_post_comment_title%":"","%_oembed_ddec2e7be960c61d7c2fed2b1910d3ff%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/cjobaQ_5s5Q?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_ddec2e7be960c61d7c2fed2b1910d3ff%":"1504122854","%_oembed_6725fff0079beb71dd1b0e6c9d98abd8%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/0nImYLd7y9s?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_6725fff0079beb71dd1b0e6c9d98abd8%":"1504122854","%_wpb_shortcodes_custom_css%":".vc_custom_1504127270883{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_thumbnail_id%":"24995","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_68e896a9e8d3a3591c6e916b5723304d%":"<iframe title=\"Drowned Out\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/cjobaQ_5s5Q?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_68e896a9e8d3a3591c6e916b5723304d%":"1567723531","%_oembed_079e39df8571ecfa6fc38bb2319c9b5f%":"<iframe title=\"Ballade in G minor, Op  118 No  3\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/0nImYLd7y9s?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_079e39df8571ecfa6fc38bb2319c9b5f%":"1567723531","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_126d78722645386668a3f319644beb3e%":"<iframe title=\"The Lamont School of Music: A Premier Music Performance School\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/U8Mvtp5DYbw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_126d78722645386668a3f319644beb3e%":"1689889659","%_oembed_5a287b585499dd2c6f4ee9554971ed66%":"<iframe title=\"Virtual Tour: Lamont School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/c0GnrKcrFZg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_5a287b585499dd2c6f4ee9554971ed66%":"1689889659","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_cd91766cd12cc998fc41f70750e61f69%":"<iframe title=\"The Lamont School of Music: A Premier Music Performance School\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/U8Mvtp5DYbw?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_cd91766cd12cc998fc41f70750e61f69%":"1714801008","%_oembed_dd538e377143842d499ca4113c1e5b30%":"<iframe title=\"Virtual Tour: Lamont School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/c0GnrKcrFZg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_dd538e377143842d499ca4113c1e5b30%":"1714801008","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"College of Music, major in music, music education, music school, music students, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Conducting, Music Education, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Sacred Music","taxonomy=schools_majors":"Composition &amp; Theory, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Western US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png"},"id":13603,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png","name":"Western US Music Schools","id":"3","type":"category"}]},{"source":"post","title":"University of Colorado Denver Music &#038; Entertainment Industry Studies","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Colorado Denver Music &#038; Entertainment Industry Studies\" width=\"600\" height=\"338\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/CU-Denver-MEIS-lead-600x338.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-colorado-denver-music-entertainment-industry-studies\/\" class=\"fc-post-link\">University of Colorado Denver Music &#038; Entertainment Industry Studies<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"1201 Larimer St, Denver, CO 80204, United States","location":{"lat":"39.7463895","lng":"-105.00233249999997","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-colorado-denver-music-entertainment-industry-studies\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]<b>The CU Denver Music and Entertainment Industry Studies (MEIS) Department offers one of the few completely contemporary-focused music departments in the U.S.<\/b>\r\n\r\n<hr \/>\r\n\r\n<strong>Focused on preparing students for the modern music industry, MEIS offers programs in:<\/strong>\r\n\r\n- Music Business*\r\n\r\n- Music Performance\r\n\r\n- Recording Arts\r\n\r\n- Singer\/Songwriter\r\n\r\n<i>*Named <\/i><i>one of the best schools to study music business by Billboard for five years in a row<\/i>\r\n\r\nBoth <b>non-audition track programs<\/b>\u00a0(Music Business &amp; Recording Arts) and <b>audition track programs<\/b>\u00a0(Music Business, Recording Arts, Music Performance, and Singer\/Songwriter) are offered. The non-audition track programs are designed for students who hope to work behind-the-scenes in the music industry. The audition track is designed for students who want to master an instrument and be a performer.\r\n\r\nMEIS faculty are industry professionals with long careers in the music industry. They help connect students to the thriving Denver music industry for <strong>internships, jobs, and performance opportunities<\/strong>. Thanks to lots of opportunities in Denver, most students are working in the Denver music industry while completing their degree.\r\n\r\nThe CU Denver MEIS Department also offers one of the few <b>Electronic Digital Instrument<\/b> programs in the U.S. Students can focus on electronic music for performance instead of a traditional instrument. Students who choose\u00a0this track receive weekly lessons from a faculty member in electronic music (using Ableton Live, Logic, etc).\r\n\r\nStudents learn in spectacular recording studios, labs, practice rooms, and performance spaces. Highlights include six state-of-the-art recording studios and the King Center performance venues (500 seat Concert Hall and 250 seat Recital Hall).\r\n\r\nCU Denver participates in the\u00a0Western Undergraduate Exchange (WUE) Program. <b>All students from Western U.S. states automatically\u00a0qualify for WUE at CU Denver.<\/b>\u00a0WUE makes college more affordable for students in participating states by limiting the cost of attendance to no more than\u00a0150% of the cost of in-state tuition.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_column_text]\r\n<p class=\"caption\">Music &amp; Entertainment Industry Studies<\/p>\r\n[\/vc_column_text][vc_video link=\"https:\/\/youtu.be\/riUJGZ4AjEA\" css=\"\"][vc_column_text css=\"\"][\/vc_column_text][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"17127,17126,26562,26563\" img_size=\"600x400\" onclick=\"\" css=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"30\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"39.7463895\" lng=\"-105.00233249999997\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14280|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png|caption^null|alt^null|title^markerOrange|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"University of Colorado Denver Music &#038; Entertainment Industry Studies","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-colorado-denver-music-entertainment-industry-studies\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Colorado Denver Music &#038; Entertainment Industry Studies\" width=\"600\" height=\"338\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/CU-Denver-MEIS-lead-600x338.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, major in music, Music colleges, music conservatory, music degrees, music education, music industry, music major, music schools, music students, music technology, UC Denver Music &amp; Entertainment Industry Studies","%_edit_lock%":"1736534171:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"1201 Larimer St, Denver, CO 80204, United States","%_wpgmp_metabox_latitude%":"39.7463895","%_wpgmp_metabox_longitude%":"-105.00233249999997","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"4\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"UC Denver Music & Entertainment Industry Studies","%_yoast_wpseo_focuskw%":"UC Denver Music & Entertainment Industry Studies","%_yoast_wpseo_metadesc%":"Located on the Auraria Campus in Downtown Denver, the University of Colorado Denver provides the full college experience in a unique urban setting. Within the College of Arts and Media, the Department of Music & Entertainment Industry Studies offers an accredited Bachelors of Science in Music degree designed to prepare students for a variety of careers in the arts and entertainment industries.","%_yoast_wpseo_linkdex%":"49","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"26561","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"UC Denver Music &amp; Entertainment Industry Studies\" href=\"http:\/\/www.ucdenver.edu\/academics\/colleges\/CAM\/academics\/programs\/Pages\/MEIS.aspx\" target=\"_blank\" rel=\"noopener\">Home Page<\/a><\/li>\r\n \t<li><a title=\"UC Denver Music &amp; Entertainment Industry Studies\" href=\"https:\/\/artsandmedia.ucdenver.edu\/areas-of-study\/music-entertainment-industry\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a title=\"UC Denver Music &amp; Entertainment Industry Studies\" href=\"https:\/\/artsandmedia.ucdenver.edu\/areas-of-study\/music-entertainment-industry\/faculty\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"UC Denver Music &amp; Entertainment Industry Studies\" href=\"https:\/\/artsandmedia.ucdenver.edu\/prospective-students\/how-to-apply\" target=\"_blank\" rel=\"noopener\">Application\/Auditions<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.ucdenver.edu\/student-services\/resources\/CostsAndFinancing\/StudentBilling\/TuitionFees\/Pages\/TuitionFees.aspx\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a title=\"UC Denver Music &amp; Entertainment Industry Studies\" href=\"http:\/\/www.ucdenver.edu\/student-services\/resources\/Scholarships\/Pages\/default.aspx\" target=\"_blank\" rel=\"noopener\">Scholarships<\/a><\/li>\r\n \t<li><a title=\"UC Denver LYNX summer music camp\" href=\"http:\/\/www.ucdenver.edu\/academics\/colleges\/CAM\/LYNX_Summer_Camps\/Pages\/LYNX_Summer_Camps.aspx\" target=\"_blank\" rel=\"noopener\">LYNX National Arts and Media Camps (Summer)<\/a><\/li>\r\n \t<li><a href=\"https:\/\/artsandmedia.ucdenver.edu\/prospective-students\/alumni-stories\" target=\"_blank\" rel=\"noopener\">CAM Alumni Stories<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"351","%_oembed_0be71a6c6dad37e1b6721041a72f7112%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/UU8j63SWGsU?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_0be71a6c6dad37e1b6721041a72f7112%":"1464134558","%_oembed_bc34b9ad30dbf43d970b413d52addf67%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/NpSUPVHsT58?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_bc34b9ad30dbf43d970b413d52addf67%":"1464134558","%_yoast_wpseo_content_score%":"30","%_wp_old_slug%":"university-colorado-denver-music-entertainment-industry-studies","%easyindexInvalidate%":"1","%_oembed_37846c5328ea53714debf8657e07e65e%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/UU8j63SWGsU?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_37846c5328ea53714debf8657e07e65e%":"1492871161","%_oembed_afe3c9653b8182c05aa072c041270b8a%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/NpSUPVHsT58?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_afe3c9653b8182c05aa072c041270b8a%":"1492871161","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"539","%_thumbnail_id%":"26560","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_e0e11e550bda0705f920fb2ad5d224cc%":"<iframe title=\"Jackson 5 &quot;I Want You Back&quot; Macy&#039;s A Cappella Challenge Winners- MIX\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/NpSUPVHsT58?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_e0e11e550bda0705f920fb2ad5d224cc%":"1701541196","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_oembed_6e2030d3fc540db75ab5a33dcbb31cb0%":"<iframe title=\"CAM Music Fest Spring 2023 Highlights\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/riUJGZ4AjEA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_6e2030d3fc540db75ab5a33dcbb31cb0%":"1736287875","taxonomy=post_tag":"College of Music, major in music, Music colleges, music conservatory, music degrees, music education, music industry, music major, music schools, music students, music technology, UC Denver Music &amp; Entertainment Industry Studies","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Recording\/Production\/Engineering","taxonomy=schools_majors":"Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Music (B.A.), Music Business, Music Industry, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Western US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png"},"id":13600,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png","name":"Western US Music Schools","id":"3","type":"category"}]},{"source":"post","title":"University of Colorado Boulder College of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Colorado Boulder College of Music\" width=\"600\" height=\"377\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/CUBoulder_CollegeOfMusicBoulderSites00919-600x377.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-colorado-boulder-college-of-music\/\" class=\"fc-post-link\">University of Colorado Boulder College of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"University of Colorado Boulder, Boulder, CO, United States","location":{"lat":"40.00758099999999","lng":"-105.26594169999998","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-colorado-boulder-college-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n\r\n<span style=\"font-size: 14pt;\"><b>Expand your range in the foothills of the Rockies.<\/b><\/span>\r\n\r\nWhether your passion is to teach, perform, compose, research or rethink music entirely, you belong at the CU Boulder College of Music. <b>We develop\u00a0multiskilled, multifaceted universal musicians<\/b>\u00a0who are equipped to participate in the 21<sup>st<\/sup>\u00a0century as artists and scholars; as broadly-based professionals with flexible career options; and as passionate, compassionate world citizens.\r\n\r\nNo two music careers will look the same, and your course of study should reflect your unique strengths and interests. Students at the CU Boulder College of Music receive <b>close mentorship from industry-leading faculty<\/b>, customize their curriculum via <b>innovative degree and certificate options<\/b>, and utilize the resources of a top research university \u2013 all in the most beautiful college town in America.\r\n\r\n<b>Fast facts:<\/b>\r\n\r\n<b><\/b>\u2022 550 total students\r\n\u2022 8:1 student-to-faculty ratio\r\n\u2022 99% BME job placement\r\n\u2022 25% of students pursue double majors\r\n\u2022 30+ ensembles in different genres\r\n\u2022 40+ Grammy awards + nominations\r\n\r\n<b>Degrees Offered<\/b>\r\n\r\n\u2022 Collaborative Piano (MM, DMA)\r\n\r\n\u2022 Composition (BM, MM)\r\n\r\n\u2022 Conducting (MM, DMA)\r\n\r\n\u2022 General Music Studies (BA)\r\n\r\n\u2022 Jazz Studies (BM, MM, DMA)\r\n\r\n\u2022 Music Education (BME, MM, PhD)\r\n\r\n\u2022 Music Production (BA) \u2013 NEW in Fall 2025!\r\n\r\n\u2022 Music Theory (MM)\r\n\r\n\u2022 Musical Theatre (BM, BFA)\r\n\r\n\u2022 Musicology (BA, BM, PhD)\r\n\r\n\u2022 Performance (BM, MM, DMA)\r\n\r\n\u2022 Performance and Pedagogy (MM, DMA)\r\n\r\n<b>Certificates Offered\u00a0<\/b>\r\n\r\n\u2022 Music Entrepreneurship (*includes a business minor)\r\n\r\n\u2022 Music Technology\r\n\r\n\u2022 Music Theory\r\n\r\n\u2022 Singing Health\r\n\r\n\u2022 Arts Administration\r\n\r\n<b>Supplemental Programs<\/b>\r\n\r\nOur innovative supplemental programs, which are designed to support each musician\u2019s holistic health and growth, include:\r\n\r\n\u2022 Entrepreneurship Center for Music\r\n\r\n\u2022 Musicians\u2019 Wellness Program\r\n\r\n\u2022 American Music Research Center\r\n\r\n\u2022 Diverse Musicians\u2019 Alliance\r\n\r\n<b>We invite you to visit our website, request information below, or contact our admissions team to learn more about becoming a Music Buff!<\/b>\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_video link=\"https:\/\/www.youtube.com\/watch?v=05v6DDw1QUA\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"23861,23859,23860,22902\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"6\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"40.00758099999999\" lng=\"-105.26594169999998\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14280|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png|caption^null|alt^null|title^markerOrange|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"University of Colorado Boulder College of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/university-of-colorado-boulder-college-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"University of Colorado Boulder College of Music\" width=\"600\" height=\"377\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/CUBoulder_CollegeOfMusicBoulderSites00919-600x377.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, Entrepreneurship, music degrees, music education, music school, University of Colorado Boulder","%_edit_lock%":"1723496996:4","%_edit_last%":"4","%_wpb_vc_js_status%":"false","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"University of Colorado Boulder, Boulder, CO, United States","%_wpgmp_metabox_latitude%":"40.00758099999999","%_wpgmp_metabox_longitude%":"-105.26594169999998","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"4\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"College of Music","%_yoast_wpseo_focuskw%":"College of Music","%_yoast_wpseo_metadesc%":"The University of Colorado Boulder College of Music offers a breathtaking location, and a comprehensive educational experience, with an array of traditional and innovative learning opportunities designed to equip students to achieve their goals on the global stage.","%_yoast_wpseo_linkdex%":"65","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"13597","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"23858","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"University of Colorado College of Music\" href=\"http:\/\/music.colorado.edu\" target=\"_blank\" rel=\"noopener\">College of Music\u00a0Homepage<\/a><\/li>\r\n \t<li><b class=\"\"><a class=\"\" title=\"Links: Please add Diversity, Equity + Inclusion after College of Music homepage https:\/\/www.colorado.edu\/music\/diversity-equity-inclusion\" href=\"https:\/\/www.colorado.edu\/music\/diversity-equity-inclusion\" target=\"_blank\" rel=\"noopener\">Diversity, Equity and Inclusion<\/a><\/b><\/li>\r\n \t<li><a title=\"University of Colorado Music Degrees\" href=\"http:\/\/www.colorado.edu\/music\/academics\/undergraduate-advising\/degrees\" target=\"_blank\" rel=\"noopener\">Degrees<\/a><\/li>\r\n \t<li><a title=\"University of Colorado Music School faculty\" href=\"http:\/\/music.colorado.edu\/faculty\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"University of Colorado undergraduate application\" href=\"http:\/\/www.colorado.edu\/music\/admissions\/prospective-undergraduates\" target=\"_blank\" rel=\"noopener\">Application Process<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.colorado.edu\/music\/admissions\/prospective-undergraduates\/auditions\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.colorado.edu\/bursar\/costs\/fallspring-costs\" target=\"_blank\" rel=\"noopener\">Tuition and Fees<\/a><\/li>\r\n \t<li><a title=\"University of Colorado College of Music\" href=\"http:\/\/www.colorado.edu\/music\/admissions\/prospective-undergraduates\/financial-aid\" target=\"_blank\" rel=\"noopener\">Scholarships<\/a><\/li>\r\n \t<li><a title=\"University of Colorado music\" href=\"http:\/\/www.colorado.edu\/music\/admissions\/prospective-graduate-students\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a title=\"University of Colorado Music School\" href=\"https:\/\/www.colorado.edu\/music\/academics\/centers-and-programs\/entrepreneurship-center-music\" target=\"_blank\" rel=\"noopener\">Entrepreneurship Center for Music<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.colorado.edu\/music\/academics\/centers-and-programs\/musicians-wellness-program\" target=\"_blank\" rel=\"noopener\">Musicians' Wellness Program<\/a><\/li>\r\n \t<li><a title=\"summer music academy University of Colorado\" href=\"http:\/\/www.colorado.edu\/music\/summer-college-music\/summer-music-academy\" target=\"_blank\" rel=\"noopener\">Summer Music Academy<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"351","%_oembed_11a5a907975f1dcc2488aaf18d362583%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/70790731\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"CU-Boulder Campus\" webkitallowfullscreen mozallowfullscreen allowfullscreen><\/iframe>","%_oembed_time_11a5a907975f1dcc2488aaf18d362583%":"1464133767","%_yoast_wpseo_content_score%":"30","%ccft_post_comment_title%":"","%easyindexInvalidate%":"1","%_oembed_6b0352c2088f16f437b6cec0393f1402%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/70790731\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"CU-Boulder Campus\" webkitallowfullscreen mozallowfullscreen allowfullscreen><\/iframe>","%_oembed_time_6b0352c2088f16f437b6cec0393f1402%":"1492836791","%_oembed_aa5f86e8337c344ad9b8b5440eb9d812%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ZeJFMB9_lMU?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_aa5f86e8337c344ad9b8b5440eb9d812%":"1501524704","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"483","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_c79d5fc87dc954eb17d6d181d47a5d72%":"<iframe title=\"Composer Fellows&#039; Initiative 2017\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ZeJFMB9_lMU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_c79d5fc87dc954eb17d6d181d47a5d72%":"1567723532","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_4c2f687fa7bca93db4b10fe11f35777f%":"<iframe title=\"CU Boulder College of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/uiP5mgYSXSI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_4c2f687fa7bca93db4b10fe11f35777f%":"1626648040","%_oembed_18de476c32b69ba488527cf21e260202%":"<iframe title=\"Cleveland Orchestra residency returns to CU Boulder\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/B4j-Y92QV_M?list=PL-z03i1qJr9oAYEVHaTJ34mAX37f8D_J9\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_18de476c32b69ba488527cf21e260202%":"1626648040","%_thumbnail_id%":"25036","%_oembed_113404d0aee77913130926d19e50f979%":"<iframe title=\"Entrepreneurship Center for Music at CU Boulder\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/l-Zm_NZ1YnM?start=47&feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_113404d0aee77913130926d19e50f979%":"1629759752","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_cf1e233a069afe012c0d67c5add1c1a5%":"<iframe title=\"Welcome to the CU Boulder College of Music!\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/05v6DDw1QUA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_cf1e233a069afe012c0d67c5add1c1a5%":"1690221418","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_356743ef0da954d1a5bc84bf179ebcf6%":"<iframe title=\"Welcome to the CU Boulder College of Music!\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/05v6DDw1QUA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_356743ef0da954d1a5bc84bf179ebcf6%":"1701552648","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"College of Music, Entrepreneurship, music degrees, music education, music school, University of Colorado Boulder","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Conducting, Music Education, Musicology, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Minor in music, Music (B.A.), Music Education, Musical Theatre, Musicology\/ Music History, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_Region":"Western US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png"},"id":13596,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png","name":"Western US Music Schools","id":"3","type":"category"}]},{"source":"post","title":"Temple University <br \/>Boyer College of Music and Dance","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Temple University music - skyline\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Temple-University-music-skyline-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/temple-university-boyer-college-of-music-and-dance\/\" class=\"fc-post-link\">Temple University <br \/>Boyer College of Music and Dance<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Boyer College of Music and Dance, North Broad Street, Philadelphia, PA, United States","location":{"lat":"39.9792301","lng":"-75.15719130000002","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/temple-university-boyer-college-of-music-and-dance\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<span style=\"font-size: 14pt;\"><strong>The Boyer College of Music and Dance, founded in 1962, is part of the Center for Performing and Cinematic Arts at Temple University, along with the School of Theater, Film and Media Arts.<\/strong> <\/span>\r\n\r\nBoyer is located on Temple's main campus in Philadelphia, Pennsylvania, less than one mile from the City\u2019s historic cultural institutions, including the Kimmel Cultural Campus, The Philadelphia Orchestra, Opera Philadelphia, Pennsylvania Ballet, Philadanco and the Philadelphia Museum of Art. Temple is also ideally located only two hours south of New York and three hours north of Washington, D.C.\r\n\r\n<strong>Undergraduate degrees include:<\/strong>\r\n\r\nBM Performance - Classical or Jazz instrumental concentrations\r\nBM Music Therapy - Classical or Jazz instrumental concentrations\r\nBM Composition - Classical or Jazz\r\nBM Music Education - Classical or Jazz instrumental concentrations\r\nBM Music History\r\nBM Music Theory\r\nBS Music Technology\r\nBS Music\r\n\r\n<strong>Graduate areas of study include:<\/strong>\r\n\r\nChoral or Wind Band Conducting\r\nCollaborative Piano and Chamber Music or Opera Coaching\r\nComposition\r\nJazz Studies\r\nMusic Education\r\nMusic Technology\r\nMusic Theory\r\nMusic Therapy\r\nOpera\r\nPerformance\r\nPiano or String Pedagogy\r\nVocal Arts\r\n\r\n<strong>Certificate programs offered in many areas to augment these programs.<\/strong>\r\n\r\nBoyer offers students numerous opportunities to perform with <strong>large and small ensembles<\/strong>, many of which perform regularly at the Temple Performing Arts Center, Kimmel Cultural Campus, Lincoln Center's Alice Tully Hall and Jazz at Lincoln Center. Boyer offers around <strong>500 concerts, performances, master classes, lectures, faculty and guest artist recitals each year<\/strong>, most of which are free and open to the public. <strong>BCM&amp;D is the five time Grammy-nominated record label of Boyer College of Music &amp; Dance<\/strong>.\r\n\r\n<hr \/>\r\n\r\n<b>Temple University\u2019s Boyer College of Music and Dance will host the 14th annual Essentially Ellington Regional High School Jazz Band Festival. The one day festival, co-sponsored by Jazz at Lincoln Center will be held Tuesday, March 4, 2025.<\/b>\r\n\r\n<hr \/>\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=4rdOptTpwyw&amp;t=9s\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=w1GK6Bfbc4E\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"4\"][vc_gallery type=\"image_grid\" images=\"22123,22124,22125,22126\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"7\" title=\"true\" description=\"false\" ajax=\"true\"][ultimate_google_map lat=\"39.9792301\" lng=\"-75.15719130000002\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14281|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png|caption^null|alt^null|title^markerGreen|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column width=\"1\/2\"][\/vc_column][vc_column width=\"1\/2\"][\/vc_column][\/vc_row]","post_title":"Temple University <br \/>Boyer College of Music and Dance","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/temple-university-boyer-college-of-music-and-dance\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Temple University music - skyline\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Temple-University-music-skyline-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Boyer College of Music, major in music, Music colleges, music conservatory, music degrees, music education, music major, music schools, music students, Temple University","%_edit_lock%":"1733857290:4","%_edit_last%":"4","%_thumbnail_id%":"22117","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"Boyer College of Music and Dance, North Broad Street, Philadelphia, PA, United States","%_wpgmp_metabox_latitude%":"39.9792301","%_wpgmp_metabox_longitude%":"-75.15719130000002","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Temple University Boyer College of Music and Dance","%_yoast_wpseo_focuskw%":"Temple University Boyer College of Music and Dance","%_yoast_wpseo_metadesc%":"Temple University Boyer College of Music and Dance offers professional training and comprehensive degree programs in music, baccalaureate through doctorate, for performers, educators, therapists, and scholars.","%_yoast_wpseo_linkdex%":"67","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"26439","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"22118","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Temple University Boyer School of Music\" href=\"http:\/\/www.temple.edu\/boyer\/\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a title=\"Boyer College of Music and Dance Temple University\" href=\"https:\/\/boyer.temple.edu\/academic-programs\/programs\/undergraduate-programs\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a title=\"Boyer College of Music and Dance Temple University\" href=\"https:\/\/boyer.temple.edu\/about\/faculty-staff\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/boyer.temple.edu\/admissions\/audition-requirements\" target=\"_blank\" rel=\"noopener\">Applications and Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bursar.temple.edu\/sites\/bursar\/files\/documents\/Tuition_Rates.pdf\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a title=\"Temple University tuition and financial aid\" href=\"https:\/\/boyer.temple.edu\/admissions\/financial-aid\" target=\"_blank\" rel=\"noopener\">Financial Aid and Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/boyer.temple.edu\/academic-programs\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/boyer.temple.edu\/about\/cpca-student-success-center\" target=\"_blank\" rel=\"noopener\">Career Services<\/a><\/li>\r\n \t<li><a title=\"Alumni Boyer College of Music and Dance\" href=\"https:\/\/www.instagram.com\/BoyerCollege\/\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_yoast_wpseo_content_score%":"30","%easyindexInvalidate%":"1","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"549","%_yoast_wpseo_primary_schools_majors%":"483","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_oembed_b1002b90b5fa83d74deb12644e204d9d%":"<iframe title=\"Welcome to a New Fall Semester at Temple University\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/4XH8P_wjKpY?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_b1002b90b5fa83d74deb12644e204d9d%":"1610823628","%_oembed_d465f2953069a02b4ca98d9a50bdd3e3%":"<iframe title=\"MOSAIC 2020 - Virtually Unstoppable\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/P_n1s9H2WxA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_d465f2953069a02b4ca98d9a50bdd3e3%":"1610823628","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_ad9373aaa77b2bed94d873d5934c0434%":"<iframe title=\"Temple University Virtual Main Campus Tour\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/7pLu22J7zSg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_ad9373aaa77b2bed94d873d5934c0434%":"1661987159","%_oembed_60a5ddf6a1f5c4ae593cc8c61c4c94a9%":"<iframe title=\"Temple University Virtual Main Campus Tour\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/7pLu22J7zSg?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_60a5ddf6a1f5c4ae593cc8c61c4c94a9%":"1701548733","%_oembed_06a42ee5d3af30c46151fe7bc2333dda%":"<iframe title=\"MOSAIC 2020 - Virtually Unstoppable\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/P_n1s9H2WxA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_06a42ee5d3af30c46151fe7bc2333dda%":"1701548733","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_oembed_92abeeb8ae259195ec74e14013194319%":"<iframe title=\"Boyer College of Music and Dance\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/4rdOptTpwyw?start=9&feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_92abeeb8ae259195ec74e14013194319%":"1725910360","%_oembed_e7b514a77641e2e0618b3d3ed86471d8%":"<iframe title=\"MOSAIC 2023\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/w1GK6Bfbc4E?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_e7b514a77641e2e0618b3d3ed86471d8%":"1725910360","taxonomy=post_tag":"Boyer College of Music, major in music, Music colleges, music conservatory, music degrees, music education, music major, music schools, music students, Temple University","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Conducting, Early Music\/ Historical Performance, Music Education, Music Technology, Music Therapy, Musical Theatre, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Minor in music, Music Education, Music Technology, Music Therapy, Musical Theatre, Musicology\/ Music History, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":13590,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"SMU Meadows School of the Arts","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"SMU Meadows School of the Arts\" width=\"600\" height=\"405\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/smunew-600x405.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/smu-meadows-school-of-the-arts\/\" class=\"fc-post-link\">SMU Meadows School of the Arts<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"6101 Bishop Blvd, Dallas, TX 75205, United States","location":{"lat":"32.8410948","lng":"-96.7861547","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/smu-meadows-school-of-the-arts\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"caption\">Students perform on and off campus and can earn double degrees.<\/p>\r\n<p class=\"intro\">Rise to higher levels of artistry and gain the practical knowledge needed to succeed in today\u2019s world at SMU Meadows School of the Arts.<\/p>\r\nThe award-winning Meadows Division of Music offers outstanding conservatory-level training along with a top-tier liberal arts education. Meadows Music is an undergraduate-focused program offering both B.M. and B.A. degrees and is one of only a few programs in the U.S. where music students can double major. Many Meadows music students simultaneously pursue degrees in engineering, English, business and a variety of other disciplines. At Meadows, you can build your dream education.\r\n\r\n<strong>The opportunities and faculty at Meadows are unparalleled.<\/strong>\u00a0Meadows Music students take private lessons, explore music history and theory, and perform in ensembles for a full season of orchestral, wind, chamber and choral concerts both on and off campus. Many study abroad in the summer. More than 200 annual performances include an opera production, a student concerto concert with the Meadows Symphony Orchestra and a gala performance at the Morton H. Meyerson Symphony Center, located in the Dallas Arts District, the largest arts district in the nation.\r\n\r\n<strong>B.M. undergraduate degrees are offered in Performance; Composition; Music Therapy; and Music Education, in addition to a B.A. in Music.<\/strong> Minors are offered in songwriting and musical theatre as well as in music. Graduate degrees are also offered. Alumni can be found in orchestras, ensembles, classrooms, clinics and companies across the world. Alumni include Jane Chu, Chair of the National Endowment for the Arts; Alessio Bax, international pianist; Yuan-Qing Yu, Associate Concertmaster, Chicago Symphony; and many more.\r\n\r\n<strong>Led by Dean Sam Holland, 2015 MTNA Teacher of the Year, Meadows is a dynamic place with extraordinary people doing significant work.<\/strong>\u00a0Find out more about our 6:1 student-to-teacher ratio, our stellar students (some already concertizing across the globe), our world-class faculty and our entrepreneurial spirit.\r\n\r\n<strong>Come see for yourself.\u00a0<\/strong>Arrange for a private lesson or campus visit today.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_video link=\"http:\/\/www.youtube.com\/watch?v=XrW907QKBOI\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"14515,11665,14511,14510\" img_size=\"500\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"61\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"32.8410948\" lng=\"-96.7861547\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14276|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png|caption^null|alt^null|title^markerPurpleNew|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"SMU Meadows School of the Arts","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/smu-meadows-school-of-the-arts\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"SMU Meadows School of the Arts\" width=\"600\" height=\"405\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/smunew-600x405.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, major in music, music degrees, music education, music school, music schools, music students, School of Music, smu meadows school of the arts, southern methodist university music","%_edit_lock%":"1721096578:9","%_edit_last%":"9","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"6101 Bishop Blvd, Dallas, TX 75205, United States","%_wpgmp_metabox_latitude%":"32.8410948","%_wpgmp_metabox_longitude%":"-96.7861547","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"smu meadows school of the arts","%_yoast_wpseo_focuskw%":"smu meadows school of the arts","%_yoast_wpseo_metadesc%":"Rise to higher levels of artistry and gain the practical knowledge needed to succeed in today\u2019s world at SMU Meadows School of the Arts.","%_yoast_wpseo_linkdex%":"65","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"11658","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"11662","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"http:\/\/www.smu.edu\/Meadows\/AreasOfStudy\/Music\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.smu.edu\/Meadows\/AreasOfStudy\/Music\/UndergraduateStudies\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.smu.edu\/Meadows\/AreasOfStudy\/Music\/Faculty\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.smu.edu\/Meadows\/AreasOfStudy\/Music\/UndergraduateStudies\/Admissions\" target=\"_blank\" rel=\"noopener\">Undergraduate Admissions<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.smu.edu\/Meadows\/AreasOfStudy\/Music\/UndergraduateStudies\/Admissions\/AuditionRep\" target=\"_blank\" rel=\"noopener\">Undergraduate Audition Requirements<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.smu.edu\/EnrollmentServices\/financialaid\/Costs\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.smu.edu\/EnrollmentServices\/financialaid\/TypesOfAid\/Scholarships\" target=\"_blank\" rel=\"noopener\">Scholarships<\/a><\/li>\r\n \t<li><a href=\"http:\/\/www.smu.edu\/Meadows\/AreasOfStudy\/Music\/GraduateStudies\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"348","%_oembed_53401d55a9fb01817f8faf2c4edfd3af%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/OCKFuUiewRM?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_53401d55a9fb01817f8faf2c4edfd3af%":"1464128452","%_oembed_f8298dbabadf7a10a94d355d5c8bc8bc%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/F9rGB82IYIs?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_f8298dbabadf7a10a94d355d5c8bc8bc%":"1464128453","%_yoast_wpseo_content_score%":"30","%_thumbnail_id%":"25903","%_oembed_1df890530b1d665dfe40619c5f1ad710%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/XrW907QKBOI?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_1df890530b1d665dfe40619c5f1ad710%":"1466788878","%ccft_post_comment_title%":"","%easyindexInvalidate%":"1","%_oembed_8dd58d50ad659364c63e90ea2e99e4e6%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/OCKFuUiewRM?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_8dd58d50ad659364c63e90ea2e99e4e6%":"1492844471","%_oembed_4a521d365e86749282dc4cecc65befee%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/XrW907QKBOI?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_4a521d365e86749282dc4cecc65befee%":"1492844471","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"483","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_dd6c57641aa93aea6c83d14ab7b9160a%":"<iframe title=\"Six Questions for Meadows Students\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/XrW907QKBOI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_dd6c57641aa93aea6c83d14ab7b9160a%":"1701542815","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"College of Music, major in music, music degrees, music education, music school, music schools, music students, School of Music, smu meadows school of the arts, southern methodist university music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Arts Management, Composition &amp; Theory, Conducting, Music Education, Musicology, Pedagogy, Performance - Instrumental, Performance - Vocal, Sacred Music","taxonomy=schools_majors":"Composition &amp; Theory, Minor in music, Music (B.A.), Music Education, Music Therapy, Performance - Instrumental, Performance - Vocal","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":13550,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"The School of Jazz and Contemporary Music at The New School","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The School of Jazz and Contemporary Music at The New School\" width=\"600\" height=\"374\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Jazz-3-600x374.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/school-of-jazz-the-new-school\/\" class=\"fc-post-link\">The School of Jazz and Contemporary Music at The New School<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"66 W 12th St, New York, NY 10011, United States","location":{"lat":"40.7355742","lng":"-73.9971764","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/school-of-jazz-the-new-school\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]\r\n<h2 class=\"intro\">The School of Jazz and Contemporary Music<b class=\"\"><\/b><\/h2>\r\n<b>Immerse yourself in the performance scene of New York City, a global center of the arts and culture.\u00a0<\/b>\r\n\r\nYour training starts the moment you set foot on our Greenwich Village campus. We surround you with a faculty of legendary professionals who\u2019ll challenge you to expand the boundaries of your art form, experiment with sound, and use your creative voice for change.\r\n\r\n<b>Artist as Mentor Approach<\/b>\r\n\r\nShape your educational journey by choosing world-class mentors aligned with your creative vision. Study different instruments and genres. Explore diverse perspectives and refine your artistry. Our project-based approach to teaching will engage you in real-world learning that inspires courage, creativity, and entrepreneurship.\r\n\r\n<b>Degree Options<\/b>\r\n\r\nStudents earn a Bachelor of Fine Arts in Jazz and Contemporary Music in one of these fields:\r\n<ul>\r\n \t<li>Bass<\/li>\r\n \t<li>Drums\/Percussion<\/li>\r\n \t<li>Electronics<\/li>\r\n \t<li>Guitar<\/li>\r\n \t<li>Harmonica<\/li>\r\n \t<li>Piano\/Keyboards<\/li>\r\n \t<li>Singer\/Songwriter<\/li>\r\n \t<li>Strings<\/li>\r\n \t<li>Trombone<\/li>\r\n \t<li>Trumpet<\/li>\r\n \t<li>Tuba<\/li>\r\n \t<li>Woodwinds<\/li>\r\n \t<li>Voice<\/li>\r\n<\/ul>\r\nSome opt to pursue our BA\/BFA program, a five-year dual-degree track leading to a BA in Liberal Arts field and a BFA in Jazz Performance.\r\n\r\nStudents can pursue a <strong>Performer-Composer Master of Music (MM) degree<\/strong>, designed for musicians whose passion lies at the intersection of composition, performance, and improvisation, or an <strong>Arts Management and Entrepreneurship (MA) degree<\/strong>, designed for performers who want to gain the necessary skills to become a multidisciplinary artist.\r\n\r\n<b>Legendary Faculty<\/b>\r\n\r\nOur faculty is made up of contemporary legends - award-winning performers, composers, band leaders, and creative technologists who teach, lead ensembles, and create a supportive and collaborative learning community.\r\n\r\n<b>Your Time to Take the Stage<\/b>\r\n\r\nOpen up opportunities for your professional and artistic growth on local and global stages. Let our legendary neighborhood - New York City\u2019s Greenwich Village - inspire you to develop new art forms, collaborate with intellectual and artistically adventurous peers, and establish lasting professional relationships.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=hd-LDr55_yo\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=ODxN7_a6tso\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"26236,26235,26237,26234\" img_size=\"600x400\" onclick=\"\" css=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"45\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"40.7365662\" lng=\"-73.99648450000001\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14281|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png|caption^null|alt^null|title^markerGreen|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"The School of Jazz and Contemporary Music at The New School","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/school-of-jazz-the-new-school\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The School of Jazz and Contemporary Music at The New School\" width=\"600\" height=\"374\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Jazz-3-600x374.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, contemporary music, jazz, major in music, majoring in music, music education, music industry, music school, music schools, music students, musical theatre, popular music, School of Jazz at the New School, The New School","%_edit_lock%":"1730257667:4","%_edit_last%":"4","%_thumbnail_id%":"26232","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"66 W 12th St, New York, NY 10011, United States","%_wpgmp_metabox_latitude%":"40.7355742","%_wpgmp_metabox_longitude%":"-73.9971764","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"School of Jazz at the New School","%_yoast_wpseo_focuskw%":"The School of Jazz and Contemporary Music at The New School","%_yoast_wpseo_metadesc%":"The School of Jazz and Contemporary Music offers talented musicians an exceptional opportunity to train with professional artists from New York City\u2019s illustrious jazz community.","%_yoast_wpseo_linkdex%":"64","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"12299","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"26233","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"The New School for Jazz and Contemporary Music \" href=\"https:\/\/www.newschool.edu\/jazz\/\" target=\"_blank\" rel=\"noopener\">Homepage<\/a><\/li>\r\n \t<li><a title=\"The New School for Jazz and Contemporary Music\" href=\"https:\/\/www.newschool.edu\/jazz\/academics\/\" target=\"_blank\" rel=\"noopener\">Majors<\/a><\/li>\r\n \t<li><a title=\"The New School for Jazz and Contemporary Music\" href=\"https:\/\/www.newschool.edu\/jazz\/faculty\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"The New School for Jazz and Contemporary Music\" href=\"https:\/\/www.newschool.edu\/jazz\/how-to-apply\/\" target=\"_blank\" rel=\"noopener\">How to Apply<\/a><\/li>\r\n \t<li><a title=\"The New School for Jazz tuition\" href=\"https:\/\/www.newschool.edu\/jazz\/tuition-fees\/\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.newschool.edu\/financial-aid\/\" target=\"_blank\" rel=\"noopener\">Financial Aid<\/a><\/li>\r\n \t<li><a title=\"The New School for Jazz and Contemporary Music\" href=\"https:\/\/www.newschool.edu\/jazz\/outcomes\/\" target=\"_blank\" rel=\"noopener\">Success &amp; Outcomes<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_oembed_d8368e411ebc4408d708a1f99bf9ffcd%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/AVdWG2AFsdA?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_d8368e411ebc4408d708a1f99bf9ffcd%":"1464126352","%_yoast_wpseo_content_score%":"60","%_wp_old_slug%":"the-new-school-for-jazz-and-contemporary-music","%easyindexInvalidate%":"1","%ccft_post_comment_title%":"","%_oembed_e715ac68409bd556bdfca6600b5b05ec%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/AVdWG2AFsdA?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_e715ac68409bd556bdfca6600b5b05ec%":"1492867517","%_oembed_41ee5acd100d427690503a5a99d165f9%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/03pWU1CsfIE?feature=oembed\" frameborder=\"0\" gesture=\"media\" allow=\"encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_41ee5acd100d427690503a5a99d165f9%":"1513543963","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"488","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_d102c2c1cb0c7c8162d9fdc2d8c698b1%":"<iframe title=\"James \u2022 Discover A New Path at The New School\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/03pWU1CsfIE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_d102c2c1cb0c7c8162d9fdc2d8c698b1%":"1567720092","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_9437655819b33a372f88a8137165c27d%":"<iframe title=\"Andr&amp;eacute;s: Crossing Musical and Scholarly Boundaries\" src=\"https:\/\/player.vimeo.com\/video\/672371349?h=a3ac31d32c&amp;dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_9437655819b33a372f88a8137165c27d%":"1666725312","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_4230be7bcb36b0fac412d7b4ea62b5f3%":"{{unknown}}","%_oembed_6ee2384e986534b8b7cf0d4106021668%":"<iframe title=\"James \u2022 Discover A New Path at The New School\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/03pWU1CsfIE?list=PLWhTJDazgMDlqZXe-Lq58QHlhBJL1p96y\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_6ee2384e986534b8b7cf0d4106021668%":"1701542961","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_oembed_0f58c689bfe15c55aa34c963a9d964a2%":"{{unknown}}","%_oembed_15d5ca55ef7a420f0899c325d005cb82%":"{{unknown}}","%_oembed_fdb982e77d82f2bb7fc342febe68fca6%":"<iframe title=\"Eddie | Be Free\u2014and a Professional | Jazz Performance\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/58-_WZGz6hI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_fdb982e77d82f2bb7fc342febe68fca6%":"1730166004","%_oembed_465e10b60e383e06250fe820ec7f260d%":"<iframe title=\"Percussion Ensemble Performance Spring 2024\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/hd-LDr55_yo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_465e10b60e383e06250fe820ec7f260d%":"1730243683","%_oembed_79eef4dce9ba9cad7f9a6e825666be58%":"<iframe title=\"Tyler: Amplifying the Power to Change Things\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ODxN7_a6tso?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_79eef4dce9ba9cad7f9a6e825666be58%":"1730243684","taxonomy=post_tag":"College of Music, contemporary music, jazz, major in music, majoring in music, music education, music industry, music school, music schools, music students, musical theatre, popular music, School of Jazz at the New School, The New School","taxonomy=schools_degrees":"Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Minor in music, Music (B.A.), Performance - Jazz Instrumental","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":13545,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Oberlin Conservatory of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Oberlin Conservatory of Music\" width=\"600\" height=\"405\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/oberlinnew2-600x405.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/oberlin-conservatory-of-music\/\" class=\"fc-post-link\">Oberlin Conservatory of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"77 W College St, Oberlin, OH 44074, United States","location":{"lat":"41.2904906","lng":"-82.21889349999998","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/oberlin-conservatory-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\">Oberlin Conservatory of Music educates students for life, by teaching them to perform and think with rigor, creativity, flexibility, and independence.<\/p>\r\nAwarded the 2009 National Medal of Arts, Oberlin is the oldest continuously operating conservatory and is one of the world\u2019s foremost professional training institutions.\r\n\r\n<img class=\"alignleft\" src=\"\/wp-content\/uploads\/2014\/10\/Oberlin2014_200x200.gif\" alt=\"Oberlin Conservatory of Music\" width=\"200\" height=\"200\" \/>Oberlin is also the only major music school in the United States that\u00a0<strong>focuses on educating undergraduate musicians<\/strong>.\u00a0 Oberlin students play in ensembles large and small from their first week on campus and are supported in taking risks that prepare them for musical leadership.\r\n\r\n<strong>At Oberlin, high expectations are the norm.<\/strong> Described by the New York Times as a \u201crural experimental haven,\u201d Oberlin presents opportunities for intensive study and immersive performance experiences. Oberlin students are showcased on the world stage in national and international tours, live-streamed concerts from campus, and through the conservatory\u2019s official recording label, in front of top critics and discerning audiences alike.\r\n\r\n<strong>At Oberlin, we prepare young musicians for remarkable careers.<\/strong> Oberlin alumni have founded numerous ensembles, including Grammy Award-winners <em>eighth blackbird<\/em> and the <em>International Contemporary Ensemble<\/em>\u2014Musical America\u2019s 2014 Ensemble of the Year\u2014as well as early music ensembles <em>Apollo\u2019s Fire<\/em> and <em>Rebel<\/em>.\u00a0 Oberlin alumni are founding members of string quartets such as Pacifica and Mir\u00f3, and are exemplary solo musicians and collaborators, including composers Christopher Rouse and the Pulitzer Prize-winner George Walker, jazz sax player and acclaimed author James McBride, violinist Jennifer Koh, Atlanta Symphony Orchestra Music Director Robert Spano, and MacArthur Award-winning pianist Jeremy Denk.\r\n\r\n<strong>Oberlin shares a campus with one of the nation\u2019s most renowned liberal arts institutions.<\/strong> It\u2019s the key reason why Oberlin invented the double degree nearly 100 years ago and why 40 new conservatory students each year elect to pursue studies in performance and composition alongside science, humanities, and other disciplines. The double degree opens the door to an enormous array of professional possibilities for life after Oberlin.\r\n\r\n<strong>Creativity &amp; Leadership: Entrepreneurship at Oberlin<\/strong>\u00a0offers students the chance to put their innovative ideas into action, in practice and preparation for professional life after Oberlin.\u00a0 This multidisciplinary, cross-campus initiative fosters a culture of smart risk-taking and provides students with funding, coaching, and other resources to launch ventures, artistic and otherwise.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_video link=\"http:\/\/www.youtube.com\/watch?v=DB-fFUF6x1w\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"12448,10881,10888,10882\" img_size=\"500\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"58\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"41.2904906 \" lng=\"-82.21889349999998\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14276|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png|caption^null|alt^null|title^markerPurpleNew|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Oberlin Conservatory of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/oberlin-conservatory-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Oberlin Conservatory of Music\" width=\"600\" height=\"405\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/oberlinnew2-600x405.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, music conservatory, music degrees, music education, music school, School of Music","%_edit_lock%":"1721096940:9","%_edit_last%":"9","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"77 W College St, Oberlin, OH 44074, United States","%_wpgmp_metabox_latitude%":"41.2904906","%_wpgmp_metabox_longitude%":"-82.21889349999998","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Oberlin Conservatory of Music","%_yoast_wpseo_focuskw%":"Oberlin Conservatory of Music","%_yoast_wpseo_metadesc%":"Oberlin Conservatory of Music educates students for life, by teaching them to perform and think with rigor, creativity, flexibility, and independence.","%_yoast_wpseo_linkdex%":"65","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"10877","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"14231","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Oberlin Conservatory of Music\" href=\"http:\/\/new.oberlin.edu\/conservatory\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a title=\"Oberlin Conservatory of Music\" href=\"http:\/\/new.oberlin.edu\/conservatory\/degrees-and-majors\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a title=\"Oberlin Conservatory of Music\" href=\"http:\/\/new.oberlin.edu\/conservatory\/faculty\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Oberlin Conservatory of Music\" href=\"https:\/\/www.oberlin.edu\/admissions-and-aid\/conservatory\" target=\"_blank\" rel=\"noopener\">Apply<\/a><\/li>\r\n \t<li><a title=\"Oberlin Conservatory of Music\" href=\"https:\/\/www.oberlin.edu\/admissions-and-aid\/conservatory\/auditions-and-interviews\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a title=\"Oberlin Conservatory of Music\" href=\"https:\/\/www.oberlin.edu\/admissions-and-aid\/tuition-and-fees\" target=\"_blank\" rel=\"noopener\">Tuition &amp; Fees<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.oberlin.edu\/admissions-and-aid\/financial-aid\" target=\"_blank\" rel=\"noopener\">Financial Aid &amp; Scholarships<\/a><\/li>\r\n \t<li><a title=\"Oberlin Conservatory of Music\" href=\"http:\/\/new.oberlin.edu\/office\/summer-programs\" target=\"_blank\" rel=\"noopener\">Summer Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.oberlin.edu\/conservatory\/life-after-oberlin-conservatory\" target=\"_blank\" rel=\"noopener\">Careers &amp; Professional Support<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"348","%_thumbnail_id%":"25907","%_oembed_7ddd7408a34efc39f5c126fe95bc9266%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/DB-fFUF6x1w?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_7ddd7408a34efc39f5c126fe95bc9266%":"1464120051","%_yoast_wpseo_content_score%":"30","%easyindexInvalidate%":"1","%ccft_post_comment_title%":"","%_oembed_fe6cbd4dc9f6bf9214cf3591df82f348%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/DB-fFUF6x1w?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_fe6cbd4dc9f6bf9214cf3591df82f348%":"1492843323","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"482","%_yoast_wpseo_primary_schools_graduateschools_majors%":"547","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_9a43ce80f273491b4edc11050f92ae48%":"<iframe title=\"Punch Brothers Residency\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/DB-fFUF6x1w?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_9a43ce80f273491b4edc11050f92ae48%":"1701545586","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_yoast_wpseo_estimated-reading-time-minutes%":"3","taxonomy=post_tag":"College of Music, music conservatory, music degrees, music education, music school, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Chamber Music, Conducting, Early Music\/ Historical Performance, Performance - Instrumental","taxonomy=schools_majors":"Collaborative Piano, Composition &amp; Theory, Computer Music, Early Music\/ Historical Performance, Minor in music, Music Technology, Musicology\/ Music History, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":13522,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"Peabody Conservatory <br \/>of The Johns Hopkins University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Peabody Conservatory music students\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Peabody-Conservatory-music-students-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/peabody-conservatory\/\" class=\"fc-post-link\">Peabody Conservatory <br \/>of The Johns Hopkins University<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"1 E Mt Vernon Pl, Baltimore, MD 21202, United States","location":{"lat":"39.2971828","lng":"-76.61520339999998","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/peabody-conservatory\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\"><strong>The Peabody Conservatory of the Johns Hopkins University empowers musicians and dancers from diverse backgrounds to create and perform at the highest level.<\/strong><\/p>\r\nPeabody fosters a rigorous, collaborative, and supportive environment where you can embark on lifelong practices of experimenting, authentically expressing yourself, and pursuing your passions.\r\n\r\nCourses of study range from <strong>classical and jazz performance, composition, ballet, and modern dance to cutting-edge programs in acoustics, recording arts and sciences, and music for new media<\/strong>. Peabody\u2019s distinguished faculty are world-class performers, teachers, and thought leaders at the forefront of the local, national, and international arts communities. They serve as role models and mentors who bring a wealth of experience to the studio and classroom, providing personalized and supportive instruction as well as the resources and guidance to help you excel professionally.\r\n\r\nThrough Peabody\u2019s diverse performance opportunities and curriculum, you will explore and engage with a wide range of styles, techniques, and artistic traditions, from established forms that have historically been excluded from the conservatory setting to new formats where performance meets technology. In addition, <strong>Peabody\u2019s unique Breakthrough Curriculum will prepare you with the communication, business, audience development, and community engagement skills necessary to be successful as a citizen-artist in an ever-changing world<\/strong>.\r\n\r\n<strong>As a division of Johns Hopkins University<\/strong>, one of the country\u2019s preeminent research institutions, Peabody combines the personalized conservatory experience with a <strong>broad network of resources and opportunities for interdisciplinary study<\/strong>, from its dual degree program to industry-leading arts and health collaborations.\r\n\r\nPeabody will prepare you for a successful professional career in the evolving arts sector by celebrating and incubating your artistic talent. You will develop the skills, connections, and confidence to make an impact with your artistry. At Peabody, world class means you can move the world. [\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/7tnhQzTgais\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=8fKcnSRP-4M\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"23043,23044,23046,23045\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"72\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"39.2971828\" lng=\"-76.61520339999998\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14281|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png|caption^null|alt^null|title^markerGreen|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Peabody Conservatory <br \/>of The Johns Hopkins University","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/peabody-conservatory\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Peabody Conservatory music students\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Peabody-Conservatory-music-students-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, majoring in music, music conservatory, music degree, music degrees, music education, music school, music schools, music students, Peabody Conservatory, Peabody Institute, School of Music, The Peabody Conservatory of The Johns Hopkins University","%_edit_lock%":"1696552632:4","%_edit_last%":"4","%_thumbnail_id%":"23048","%_oembed_dbd8e28b1475edad56e39e6d7efb398b%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Ha5y7FRyJ_k?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_dbd8e28b1475edad56e39e6d7efb398b%":"1464064184","%_oembed_4fae8b12455150bc947a38a6eb1251f1%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Bk20ojJrAeg?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_4fae8b12455150bc947a38a6eb1251f1%":"1464064184","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"1 E Mt Vernon Pl, Baltimore, MD 21202, United States","%_wpgmp_metabox_latitude%":"39.2971828","%_wpgmp_metabox_longitude%":"-76.61520339999998","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Peabody Conservatory","%_yoast_wpseo_focuskw%":"Peabody Conservatory","%_yoast_wpseo_metadesc%":"What makes Peabody Conservatory a great place to develop your musical talents?","%_yoast_wpseo_linkdex%":"72","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"23042","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"23049","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/peabody.jhu.edu\/\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/peabody.jhu.edu\/academics\/instruments-areas-of-study\/\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/peabody.jhu.edu\/faculty\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/peabody.jhu.edu\/audition-apply\/\" target=\"_blank\" rel=\"noopener\">Apply<\/a><\/li>\r\n \t<li><a href=\"https:\/\/peabody.jhu.edu\/audition-apply\/auditions\/\" target=\"_blank\" rel=\"noopener\">Audition Specifics<\/a><\/li>\r\n \t<li><a href=\"https:\/\/peabody.jhu.edu\/audition-apply\/tuition-fees\/\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/peabody.jhu.edu\/audition-apply\/financial-aid-scholarships\/prospective-students\/scholarships\/\" target=\"_blank\" rel=\"noopener\">Financial Aid\/ Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/peabody.jhu.edu\/preparatory\/ways-to-study\/departments\/summer-session\/\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/peabody.jhu.edu\/life-at-peabody\/career-services\/\" target=\"_blank\" rel=\"noopener\">Career Support (LAUNCHpad)<\/a><\/li>\r\n \t<li><a href=\"https:\/\/magazine.peabody.jhu.edu\/peabody-post\/\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_oembed_b197d7ff63e03f8abfd88eaa9d8beab9%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/K4YIj3rAeCo?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_b197d7ff63e03f8abfd88eaa9d8beab9%":"1466018339","%_oembed_ea4ce5e0183bb4b153afc5448f48a192%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/tWXEpOAeGcc?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_ea4ce5e0183bb4b153afc5448f48a192%":"1466018339","%_yoast_wpseo_content_score%":"60","%ccft_post_comment_title%":"","%easyindexInvalidate%":"1","%_oembed_72ef8809001e922a8e77e44aec21ac0b%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/K4YIj3rAeCo?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_72ef8809001e922a8e77e44aec21ac0b%":"1492885351","%_oembed_628b30ab699cce86aed1b958b7ef8e71%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/tWXEpOAeGcc?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_628b30ab699cce86aed1b958b7ef8e71%":"1492885351","%_yoast_wpseo_primary_schools_degrees%":"480","%_yoast_wpseo_primary_schools_majors%":"579","%_oembed_cce1120514bbd4dc85332790487b3faf%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/3NAJ4VcuwpI?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_cce1120514bbd4dc85332790487b3faf%":"1519322159","%_oembed_1b96274f5d0f583fd8d7b0371b5defc1%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/UkvYOTJg9sM?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_1b96274f5d0f583fd8d7b0371b5defc1%":"1519322159","%_yoast_wpseo_primary_schools_graduateschools_majors%":"547","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_8e03731548f840c38c1618736d5c57e7%":"<iframe title=\"World Class Means You Can Move the World\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/3NAJ4VcuwpI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_8e03731548f840c38c1618736d5c57e7%":"1567724339","%_oembed_e56728fdb8d07ffb7bc9d1e63d6275fb%":"<iframe title=\"Mahler: Symphony No. 1 in D major, &quot;Titan&quot;, PSO, Marin Alsop\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/UkvYOTJg9sM?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_e56728fdb8d07ffb7bc9d1e63d6275fb%":"1567724339","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_7ae4b9009de3e6ec0b76784cb89b7cc9%":"<iframe title=\"World Class Means You Can Move the World\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/7tnhQzTgais?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_7ae4b9009de3e6ec0b76784cb89b7cc9%":"1633124185","%_oembed_cb1e0af8f757bad0c4a904b173c5c88d%":"<iframe title=\"Peabody&#039;s Breakthrough Curriculum\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/LYKk9EAM6yA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_cb1e0af8f757bad0c4a904b173c5c88d%":"1633124185","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_dc65fce11a2d993ceb8d5c1898ef6c71%":"<iframe title=\"Peabody&#039;s LAUNCHPad &amp; Breakthrough Curriculum\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/8fKcnSRP-4M?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_dc65fce11a2d993ceb8d5c1898ef6c71%":"1666972710","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_132db5949ff13d5611fca026a5287f14%":"<iframe title=\"World Class Means You Can Move the World\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/7tnhQzTgais?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_132db5949ff13d5611fca026a5287f14%":"1701571874","%_oembed_4add0b4f7ed19b325ad536380d34636d%":"<iframe title=\"Peabody&#039;s LAUNCHPad &amp; Breakthrough Curriculum\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/8fKcnSRP-4M?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_4add0b4f7ed19b325ad536380d34636d%":"1701571875","taxonomy=post_tag":"College of Music, majoring in music, music conservatory, music degree, music degrees, music education, music school, music schools, music students, Peabody Conservatory, Peabody Institute, School of Music, The Peabody Conservatory of The Johns Hopkins University","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Chamber Music, Composition &amp; Theory, Computer Music, Conducting, Early Music\/ Historical Performance, Music Education, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/Production\/Engineering","taxonomy=schools_majors":"Chamber Music, Composition &amp; Theory, Computer Music, Conducting, Early Music\/ Historical Performance, Music (B.A.), Music Education, Musicology\/ Music History, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":13518,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Mannes School of Music at The New School","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mannes School of Music at The New School\" width=\"600\" height=\"364\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Mannes-3-600x364.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/mannes-school-of-music-the-new-school\/\" class=\"fc-post-link\">Mannes School of Music at The New School<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Mannes School of Music at The New School, West 13th Street, New York, NY, United States","location":{"lat":"40.73652609999999","lng":"-73.99653810000001","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/mannes-school-of-music-the-new-school\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]<b>Join an innovative conservatory, where classical music is reimagined for the 21st century.\u00a0<\/b>\r\n\r\nMannes offers a rare balance between the traditional and the experimental, in a highly collaborative community of musicians, composers, conductors, and theater trailblazers who respond to the world through their art.\r\n\r\n<b>A New Kind of Conservatory<\/b>\r\n\r\nMannes offers rigorous training and unique opportunities to grow as an artist through cross-disciplinary work, entrepreneurship, and social engagement. Study with legendary faculty mentors, join world-class ensembles, and gain access to groundbreaking artists, both on our New York City campus and on stages across the city and beyond.\r\n\r\n<b>Degree Options<\/b>\r\n\r\nMannes offers BM, MM, and Professional Studies Diploma Classical Music programs in:\r\n<ul>\r\n \t<li>Brass<\/li>\r\n \t<li>Collaborative Piano<\/li>\r\n \t<li>Composition<\/li>\r\n \t<li>Guitar<\/li>\r\n \t<li>Percussion<\/li>\r\n \t<li>Piano &amp; Harpsichord<\/li>\r\n \t<li>Strings<\/li>\r\n \t<li>Theory<\/li>\r\n \t<li>Voice<\/li>\r\n \t<li>Woodwinds<\/li>\r\n<\/ul>\r\nUndergraduate students can deepen their abilities as a performer and gain skills in business, leadership, and entrepreneurship by combining their BM degree with the MA in Arts Management and Entrepreneurship, graduating with both degrees in five years.\r\n\r\nStudents can also pursue a Performer-Composer Master of Music (MM) degree, designed for musicians whose passion lies at the intersection of composition, performance.\r\n\r\n<b>New York City as Your Stage<\/b>\r\n\r\nWith New York City as your classroom, jumpstart your career and:\r\n<ul>\r\n \t<li>Play and record at landmark venues like Lincoln Center and Carnegie Hall.<\/li>\r\n \t<li>Participate in cutting-edge performances with our many ensembles.<\/li>\r\n \t<li>Perform with the Mannes Orchestra and Martha Graham Dance Company at City Center.<\/li>\r\n \t<li>Train for positions with the world\u2019s best orchestras, music presenters, and arts organizations.<\/li>\r\n<\/ul>\r\n<b>Faculty at the Top of Their Fields<\/b>\r\n\r\nOur faculty is made up of luminaries honored for their achievements with major awards - Grammy, MacArthur Genius, Pulitzer, Guggenheim, Avery Fisher. Get hands-on instruction and access to a wealth of experience and connections in a supportive learning environment.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_video link=\"https:\/\/youtu.be\/Hb9CQNTYtYs?list=PLWhTJDazgMDlqZXe-Lq58QHlhBJL1p96y\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"26227,26228,26229,26230\" img_size=\"600x400\" onclick=\"\" css=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"44\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"40.73652609999999\" lng=\"-73.99653810000001\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14281|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png|caption^null|alt^null|title^markerGreen|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row][vc_row][vc_column][\/vc_column][\/vc_row]","post_title":"Mannes School of Music at The New School","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/mannes-school-of-music-the-new-school\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mannes School of Music at The New School\" width=\"600\" height=\"364\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Mannes-3-600x364.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, major in music, majoring in music, Mannes College, Mannes School of Music at the New School, music education, music industry, music school, music schools, music students, musical theatre, The New School for Music","%_edit_lock%":"1730251229:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"Mannes School of Music at The New School, West 13th Street, New York, NY, United States","%_wpgmp_metabox_latitude%":"40.73652609999999","%_wpgmp_metabox_longitude%":"-73.99653810000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Mannes School of Music","%_yoast_wpseo_focuskw%":"Mannes School of Music","%_yoast_wpseo_metadesc%":"Mannes School of Music in New York City seeks to develop citizen artists who engage with the world in traditional, new, and emerging forms of practice.","%_yoast_wpseo_linkdex%":"65","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"12305","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"26226","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Mannes College The New School for Music\" href=\"https:\/\/www.newschool.edu\/mannes\/\" target=\"_blank\" rel=\"noopener noreferrer\">School of Music Homepage<\/a><\/li>\r\n \t<li><a title=\"Mannes College The New School for Music\" href=\"http:\/\/www.newschool.edu\/mannes\/academics\/\" target=\"_blank\" rel=\"noopener noreferrer\">Majors<\/a><\/li>\r\n \t<li><a title=\"Mannes College The New School for Music\" href=\"https:\/\/www.newschool.edu\/mannes\/faculty\/\" target=\"_blank\" rel=\"noopener noreferrer\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Mannes College The New School for Music\" href=\"https:\/\/www.newschool.edu\/mannes\/how-to-apply-undergraduate\/\" target=\"_blank\" rel=\"noopener noreferrer\">How to Apply (Undergraduate)<\/a><\/li>\r\n \t<li><a title=\"Mannes College The New School for Music\" href=\"https:\/\/www.newschool.edu\/mannes\/how-to-apply-graduate\/\" target=\"_blank\" rel=\"noopener noreferrer\">How to Apply (Graduate)<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.newschool.edu\/mannes\/tuition-fees\/\" target=\"_blank\" rel=\"noopener noreferrer\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.newschool.edu\/financial-aid\/\" target=\"_blank\" rel=\"noopener noreferrer\">Financial Aid<\/a><\/li>\r\n \t<li><a title=\"Mannes College The New School for Music\" href=\"https:\/\/www.newschool.edu\/mannes\/outcomes\/\" target=\"_blank\" rel=\"noopener noreferrer\">Success &amp; Outcomes<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_oembed_eceb7d47e930f00d992f4a2b7cbd975a%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/33405418\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"Music School New York | Are You New School?\" webkitallowfullscreen mozallowfullscreen allowfullscreen><\/iframe>","%_oembed_time_eceb7d47e930f00d992f4a2b7cbd975a%":"1463979149","%_yoast_wpseo_content_score%":"60","%_oembed_0fabef4bb1e877572dc5cadc5e2fef41%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/33405418\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"Music School New York | Are You New School?\" webkitallowfullscreen mozallowfullscreen allowfullscreen><\/iframe>","%_oembed_time_0fabef4bb1e877572dc5cadc5e2fef41%":"1492840857","%easyindexInvalidate%":"1","%ccft_post_comment_title%":"","%_thumbnail_id%":"26225","%_oembed_a18f4cf561ccdfa5cdc6f343fe0d14b0%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/51589652\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"Timelapse - Lighthouse (Oct 2012)\" webkitallowfullscreen mozallowfullscreen allowfullscreen><\/iframe>","%_oembed_time_a18f4cf561ccdfa5cdc6f343fe0d14b0%":"1513543382","%_oembed_c0280be64765e5ceae498db97475b1b6%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Hb9CQNTYtYs?feature=oembed\" frameborder=\"0\" gesture=\"media\" allow=\"encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_c0280be64765e5ceae498db97475b1b6%":"1513543382","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_43534d9911376dacfe19fec218a392e3%":"<iframe title=\"Julia \u2022 Discover A New Path at The New School\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Hb9CQNTYtYs?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_43534d9911376dacfe19fec218a392e3%":"1567724823","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_wp_old_slug%":"mannes-college-the-new-school-for-music","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_ee2221d502fb74e5ca2b61809143b408%":"<iframe title=\"Jaden: Performing as a Means of Self-Discovery\" src=\"https:\/\/player.vimeo.com\/video\/689378131?h=f21625e10a&amp;dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_ee2221d502fb74e5ca2b61809143b408%":"1666726245","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_08d9f34dea2cb24d8ef7c907b307ac20%":"{{unknown}}","%_oembed_58cf4f2b7d45efd2477cba67fcdd596e%":"<iframe title=\"Julia \u2022 Discover A New Path at The New School\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Hb9CQNTYtYs?list=PLWhTJDazgMDlqZXe-Lq58QHlhBJL1p96y\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_58cf4f2b7d45efd2477cba67fcdd596e%":"1701541853","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_oembed_465e10b60e383e06250fe820ec7f260d%":"<iframe title=\"Percussion Ensemble Performance Spring 2024\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/hd-LDr55_yo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_465e10b60e383e06250fe820ec7f260d%":"1730058909","taxonomy=post_tag":"College of Music, major in music, majoring in music, Mannes College, Mannes School of Music at the New School, music education, music industry, music school, music schools, music students, musical theatre, The New School for Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Arts Management, Composition &amp; Theory, Conducting, Music Entrepreneurship, Performance - Instrumental, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Performance - Instrumental, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":13493,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"The Liverpool Institute for Performing Arts &#8211; LIPA (UK)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Liverpool Institute for Performing Arts &#8211; LIPA (UK)\" width=\"600\" height=\"405\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/lipanew-600x405.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/liverpool-institute-for-performing-arts\/\" class=\"fc-post-link\">The Liverpool Institute for Performing Arts &#8211; LIPA (UK)<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Liverpool Institute for Performing Arts, Liverpool, United Kingdom","location":{"lat":"53.39968979999999","lng":"-2.971997299999998","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/liverpool-institute-for-performing-arts\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]<span style=\"font-size: 14pt;\"><b>LIPA offers degrees in all areas of popular, contemporary and commercial music including instrumental and vocal performance, songwriting, production. We also offer degrees in related areas such as music management and sound technology.<\/b><\/span>\r\n\r\n<em>Focusing on popular, non-classical music, we design our programs to meet the changing demands of the arts and entertainment industries. \u00a0<\/em>\r\n\r\n<span style=\"font-size: 14pt;\"><strong>Fast Facts<\/strong><\/span>\r\n\r\n\u2022 More affordable than many U.S. schools\r\n\r\n\u2022 Competitive admission\r\n\r\n\u2022 3-year undergraduate degrees, 1-year graduate (master\u2019s) degrees\r\n\r\n\u2022 1:1 student to faculty instrumental\/vocal training tailored to student needs (on performance based music courses only)\r\n\r\n\u2022 <b>No<\/b> general education classes\r\n\r\n\u2022 80+ dedicated performance and technical spaces including 6 recording studios open 24\/7\r\n\r\n\u2022 More than 50 performances annually, from dance shows to musicals, from contemporary dramas to music and film festivals\r\n\r\n\u2022 Faculty (known as \u201cTutors\u201d) are active producers, writers, performers. 1:10 staff:student ratio\r\n\r\n\u2022 One of Billboard\u2019s Top Music Business Schools for a third consecutive time\r\n\r\n\u2022 Recent master classes by Paul McCartney, Mark Ronson, Robert Plant, John Altman, Maria Torres, Ellen Beth Abdi, Denise Harris and Mike Joyce\r\n\r\n\u2022 Based in the city of Liverpool, England\u2019s only UNESCO World City of Music\r\n\r\n\u2022 Hosting the July 2025 UK\/Europe conference of The Association for Popular Music Education (APME) Conference\r\n\r\n<hr \/>\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=S9BcJG82cMM&amp;t=10s\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/soundcloud.com\/ian-janco\/ijlife\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"10802,10735,10730,10809\" img_size=\"300x200\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"55\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"53.39968979999999\" lng=\"-2.971997299999998\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14278|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][vc_column_text][\/vc_column_text][\/vc_column][\/vc_row]","post_title":"The Liverpool Institute for Performing Arts &#8211; LIPA (UK)","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/liverpool-institute-for-performing-arts\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Liverpool Institute for Performing Arts &#8211; LIPA (UK)\" width=\"600\" height=\"405\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/lipanew-600x405.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, major in music, music careers, music education, music school, School of Music, The Liverpool Institute for Performing Arts","%_edit_lock%":"1734118962:4","%_edit_last%":"4","%_thumbnail_id%":"25904","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"Liverpool Institute for Performing Arts, Liverpool, United Kingdom","%_wpgmp_metabox_latitude%":"53.39968979999999","%_wpgmp_metabox_longitude%":"-2.971997299999998","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"5\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"The Liverpool Institute for Performing Arts","%_yoast_wpseo_focuskw%":"The Liverpool Institute for Performing Arts","%_yoast_wpseo_metadesc%":"The Liverpool Institute for Performing Arts (LIPA) was co-founded in 1996 by Sir Paul McCartney. LIPA\u2019s 750 students hail from 35 different countries.","%_yoast_wpseo_linkdex%":"59","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"10800","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"10801","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Liverpool Institute for Performing Arts (LIPA)\" href=\"https:\/\/www.lipa.ac.uk\/\" target=\"_blank\" rel=\"noopener noreferrer\">LIPA Homepage<\/a><\/li>\r\n \t<li><a title=\"Liverpool Institute for Performing Arts (LIPA)\" href=\"https:\/\/lipa.ac.uk\/music\" target=\"_blank\" rel=\"noopener noreferrer\">Music Programmes<\/a><\/li>\r\n \t<li><a title=\"Liverpool Institute for Performing Arts (LIPA)\" href=\"https:\/\/eur01.safelinks.protection.outlook.com\/?url=https%3A%2F%2Flipa.ac.uk%2Fwhy-lipa%2Fstaff%2F&amp;data=05%7C01%7Cr.duncan%40lipa.ac.uk%7C06b35118600f4c74f47208da90528037%7C5f6b8968d3c2422f87f2bf54bef69ee9%7C0%7C0%7C637980982752484669%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&amp;sdata=ib7Yg1RfLk6FyttwV03AqN5yr3iWZawyLIZXnzh9H8I%3D&amp;reserved=0\" target=\"_blank\" rel=\"noopener noreferrer\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Liverpool Institute for Performing Arts (LIPA)\" href=\"https:\/\/lipa.ac.uk\/apply\/finance\/\" target=\"_blank\" rel=\"noopener noreferrer\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/eur01.safelinks.protection.outlook.com\/?url=https%3A%2F%2Flipa.ac.uk%2Fapply%2Finternational-students%2F&amp;data=05%7C01%7Cr.duncan%40lipa.ac.uk%7C06b35118600f4c74f47208da90528037%7C5f6b8968d3c2422f87f2bf54bef69ee9%7C0%7C0%7C637980982752484669%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&amp;sdata=sArLqEaGTBpeSqzjov1h8iUXjOaLcjfja7bb6zeUcCs%3D&amp;reserved=0\" target=\"_blank\" rel=\"noopener\">International Applicants<\/a><\/li>\r\n \t<li><a title=\"Liverpool Institute for Performing Arts (LIPA)\" href=\"https:\/\/eur01.safelinks.protection.outlook.com\/?url=https%3A%2F%2Flipa.ac.uk%2Falumni%2F&amp;data=05%7C01%7Cr.duncan%40lipa.ac.uk%7C06b35118600f4c74f47208da90528037%7C5f6b8968d3c2422f87f2bf54bef69ee9%7C0%7C0%7C637980982752484669%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7C&amp;sdata=0UhIhgiEOsOr1eX9dVs%2BmzKMRGuTafCX2qIIdNEv0%2Fc%3D&amp;reserved=0\" target=\"_blank\" rel=\"noopener noreferrer\">Alumni Spotlight<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"350","%_oembed_cf52c3eb1dc752f97869334134422ef0%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/RQisobv7zes?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_cf52c3eb1dc752f97869334134422ef0%":"1463970834","%_yoast_wpseo_content_score%":"60","%easyindexInvalidate%":"1","%_yoast_wpseo_title%":"The Liverpool Institute for Performing Arts (LIPA)","%_oembed_783f0cf70a2f18b2267bf0c4948809c7%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/RQisobv7zes?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_783f0cf70a2f18b2267bf0c4948809c7%":"1492862083","%ccft_post_comment_title%":"","%_oembed_ebc37a3997db70a93726783330495a67%":"<iframe width=\"500\" height=\"400\" scrolling=\"no\" frameborder=\"no\" src=\"https:\/\/w.soundcloud.com\/player\/?visual=true&url=https%3A%2F%2Fapi.soundcloud.com%2Ftracks%2F312118284&show_artwork=true&maxwidth=500&maxheight=750\"><\/iframe>","%_oembed_time_ebc37a3997db70a93726783330495a67%":"1497739436","%_oembed_6eaac5cd12aefe27fffa2bf868286360%":"<iframe width=\"500\" height=\"400\" scrolling=\"no\" frameborder=\"no\" src=\"https:\/\/w.soundcloud.com\/player\/?visual=true&url=https%3A%2F%2Fapi.soundcloud.com%2Ftracks%2F312118284&show_artwork=true&maxwidth=500&maxheight=750\"><\/iframe>","%_oembed_time_6eaac5cd12aefe27fffa2bf868286360%":"1497740251","%_wp_old_slug%":"the-liverpool-institute-for-performing-arts","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"481","%_oembed_00c3f7abed8e3fb19daa9af9a877a048%":"<iframe title=\"Life by Ian Janco\" width=\"500\" height=\"400\" scrolling=\"no\" frameborder=\"no\" src=\"https:\/\/w.soundcloud.com\/player\/?visual=true&url=https%3A%2F%2Fapi.soundcloud.com%2Ftracks%2F312118284&show_artwork=true&maxwidth=500&maxheight=750&dnt=1\"><\/iframe>","%_oembed_time_00c3f7abed8e3fb19daa9af9a877a048%":"1567728347","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_oembed_d415f39d032c782aca9c51056bfa9547%":"<iframe title=\"Graduation Highlights 2020\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/lm7msKPUObE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_d415f39d032c782aca9c51056bfa9547%":"1633728369","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_d846c0e09024d22345576fe76dbe6560%":"<iframe title=\"Graduation Highlights 2020\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/lm7msKPUObE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_d846c0e09024d22345576fe76dbe6560%":"1701547461","%_oembed_a17ec2a4d9ba53161cb1beb1229804fc%":"<iframe title=\"Life by Ian Janco\" width=\"500\" height=\"310\" scrolling=\"no\" frameborder=\"no\" src=\"https:\/\/w.soundcloud.com\/player\/?visual=true&url=https%3A%2F%2Fapi.soundcloud.com%2Ftracks%2F312118284&show_artwork=true&maxheight=310&maxwidth=500\"><\/iframe>","%_oembed_time_a17ec2a4d9ba53161cb1beb1229804fc%":"1701547462","%_monsterinsights_sitenote_active%":"0","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_wpb_post_custom_layout%":"default","%_oembed_ac5c681b36d122a84251241871bb7af9%":"<iframe title=\"Graduation Highlights 2024\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/S9BcJG82cMM?start=10&feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_ac5c681b36d122a84251241871bb7af9%":"1725663773","taxonomy=post_tag":"College of Music, major in music, music careers, music education, music school, School of Music, The Liverpool Institute for Performing Arts","taxonomy=schools_degrees":"Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Arts Management, Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Electronic Music, Music Business, Music Industry, Music Technology, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"International Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png"},"id":13488,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png","name":"International Music Schools","id":"4","type":"category"}]},{"source":"post","title":"Lawrence University Conservatory of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lawrence University Conservatory of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Lawrence-University-music-1-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/lawrence-university-conservatory-of-music\/\" class=\"fc-post-link\">Lawrence University Conservatory of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"711 E Boldt Way, Appleton, WI 54911, United States","location":{"lat":"44.2600613","lng":"-88.3964896","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/lawrence-university-conservatory-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\"><strong>Lawrence University delivers a holistic, 21st-century music education to empower musicians who are smart, innovative, entrepreneurial, civic-minded, and collaborative.<\/strong><\/p>\r\nAs both a world-class Conservatory of Music and a nationally ranked College of Liberal Arts and Sciences, Lawrence offers music students 4 degree options:\r\n<ul>\r\n \t<li><strong>Bachelor of Music (B.Mus.)<\/strong>\u00a0in Performance, Music Education, Composition, or Music Theory<\/li>\r\n \t<li><strong>Bachelor of Arts (B.A.)<\/strong>\u00a0in Music \u2013 our most flexible music degree<\/li>\r\n \t<li><strong>Bachelor of Musical Arts (B.M.A)<\/strong>\u00a0in Jazz and Contemporary Improvisation \u2013 and for students interested in a broad range of contemporary music styles and instruments<\/li>\r\n \t<li><strong>Five-year Double Degree (B.Mus.\/B.A.)\u00a0<\/strong>in music and at least one other field<\/li>\r\n<\/ul>\r\n&nbsp;\r\n\r\n<strong>Comprehensive Curriculum<\/strong>\r\n\r\nIn addition to rigorous musical training through lessons, ensembles, and theory and musicology coursework, Lawrence provides opportunities to explore entrepreneurship, recording\/production, world music, improvisation, wellness, and a host of minor options.\r\n\r\n<strong>Ensembles and Performance<\/strong>\r\n\r\nBetween our bands, choirs, orchestras, operas, jazz ensembles, musicals, world music ensembles, chamber ensembles, improv groups, and contemporary music offerings, performance opportunities abound at Lawrence.\r\n\r\n<strong>Mentorship<\/strong>\r\n\r\nWith a strong focus on mentorship, Lawrence provides countless opportunities to work closely with faculty for a highly personal and individualized experience. As an entirely undergraduate institution, you will always be taught by faculty (not graduate assistants) and you will never compete with graduate students for opportunities.\r\n\r\n<strong>Affordability<\/strong>\r\n\r\nWith<strong>\u00a099%<\/strong> of our students receiving financial support through scholarships and financial aid, and 75% of our students receiving need-based financial aid, we work hard to make Lawrence affordable for students and families.\r\n\r\n<strong>Engagement Beyond the Classroom<\/strong>\r\n\r\nAffect positive social change through our innovative community outreach program, <em>Music for All<\/em>. Gain real-world arts experience through internships with the New York Jazz Academy, the Deep Listening Institute, Carnegie Hall Community Programs, the Lyric Opera, and more.\r\n\r\n<hr \/>\r\n\r\n<i class=\"\">We invite you to explore our current <\/i><a class=\"\" href=\"https:\/\/www.lawrence.edu\/admissions\/visit\" target=\"_blank\" rel=\"noopener\"><span class=\"\"><b class=\"\"><i class=\"\">virtual and in-person visit options<\/i><\/b><\/span><\/a><i class=\"\"> to learn more about the Lawrence community!<\/i>\r\n\r\n<hr \/>\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=LAM6O11dIUI\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=tcl2S7CDE8E\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"25049,25047,25048,25050\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"36\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"44.2600613\" lng=\"-88.3964896\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14276|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png|caption^null|alt^null|title^markerPurpleNew|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Lawrence University Conservatory of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/lawrence-university-conservatory-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lawrence University Conservatory of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Lawrence-University-music-1-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, Lawrence University, Lawrence University Conservatory of Music, majoring in music, music conservatory, music degrees, music education, music major, music school, School of Music","%_edit_lock%":"1721425762:4","%_edit_last%":"4","%_thumbnail_id%":"25045","%_wpb_vc_js_status%":"false","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"711 E Boldt Way, Appleton, WI 54911, United States","%_wpgmp_metabox_latitude%":"44.2600613","%_wpgmp_metabox_longitude%":"-88.3964896","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Lawrence University Conservatory","%_yoast_wpseo_focuskw%":"Lawrence University Conservatory","%_yoast_wpseo_metadesc%":"The Lawrence University Conservatory of Music offers you a rare blend of professional education in music and liberal arts, a combination that has produced","%_yoast_wpseo_linkdex%":"69","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"11822","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"25046","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Lawrence University Conservatory of Music\" href=\"https:\/\/www.lawrence.edu\/academics\/conservatory\" target=\"_blank\" rel=\"noopener\">Conservatory of Music Homepage<\/a><\/li>\r\n \t<li><a title=\"Lawrence University Conservatory of Music\" href=\"https:\/\/www.lawrence.edu\/academics\/degrees\" target=\"_blank\" rel=\"noopener\">Degree Options<\/a><\/li>\r\n \t<li><a title=\"Lawrence University Conservatory of Music\" href=\"https:\/\/www.lawrence.edu\/academics\/conservatory\/faculty\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Lawrence University Conservatory of Music\" href=\"https:\/\/www.lawrence.edu\/admissions-aid\/conservatory-admissions\/apply-audition\" target=\"_blank\" rel=\"noopener\">Application and Audition Information<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.lawrence.edu\/admissions-aid\/conservatory-admissions\/apply-audition\/audition-requirements\" target=\"_blank\" rel=\"noopener\">Audition Requirements by Instrument<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.lawrence.edu\/offices\/financial-aid\/tuition-fees\" target=\"_blank\" rel=\"noopener\">Tuition and Fees<\/a><\/li>\r\n \t<li><a title=\"Lawrence University Conservatory of Music\" href=\"https:\/\/www.lawrence.edu\/admissions-aid\/aid-affordability\" target=\"_blank\" rel=\"noopener\">Financial Aid and Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.lawrence.edu\/offices\/career-center\" target=\"_blank\" rel=\"noopener\">Career Resources<\/a><\/li>\r\n \t<li><a title=\"Lawrence University Conservatory of Music\" href=\"https:\/\/www.lawrence.edu\/academics\/conservatory\/outcomes\" target=\"_blank\" rel=\"noopener\">About Our Graduates<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"348","%_oembed_20608434336e0b75269f4c307b2bfec2%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/bEFXbOhRtW4?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_20608434336e0b75269f4c307b2bfec2%":"1463969862","%_oembed_93b219e74b31edd2f9952beeecb23c44%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/PoL0Odcmqno?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_93b219e74b31edd2f9952beeecb23c44%":"1463969862","%_oembed_e83ef0314246c0b8a704825cda83e20e%":"<iframe width=\"500\" height=\"375\" src=\"https:\/\/www.youtube.com\/embed\/UL8iJ4y32Vk?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_e83ef0314246c0b8a704825cda83e20e%":"1465505343","%_yoast_wpseo_content_score%":"60","%easyindexInvalidate%":"1","%_oembed_9eb744a8195ffdb501ce683ee5f9471b%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/3Yxp-Re1YWM?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_9eb744a8195ffdb501ce683ee5f9471b%":"1471902554","%_oembed_9daabf968132a51ad7fd92220a5499f3%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/qCK3lNbJdJQ?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_9daabf968132a51ad7fd92220a5499f3%":"1471902554","%_oembed_c7e17f6a3a3fa27f42f616b3026cfdcb%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/TyKOdWDpok8?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_c7e17f6a3a3fa27f42f616b3026cfdcb%":"1471902554","%_yoast_wpseo_title%":"Lawrence University Conservatory of Music - Music Major","%ccft_post_comment_title%":"","%_oembed_1a3b0d1aacaba5a4780b852985d77882%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/3Yxp-Re1YWM?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_1a3b0d1aacaba5a4780b852985d77882%":"1492842936","%_oembed_bf12892e11a30bc2bf09d3e8fb8a4dbe%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/qCK3lNbJdJQ?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_bf12892e11a30bc2bf09d3e8fb8a4dbe%":"1492842936","%_oembed_94a8098bc847adbe0cd797add564e1e5%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/TyKOdWDpok8?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_94a8098bc847adbe0cd797add564e1e5%":"1492842936","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"483","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"<a href=\"https:\/\/www.facebook.com\/LU.Conservatory\" rel=\"noopener\" target=\"_blank\">https:\/\/www.facebook.com\/LU.Conservatory<\/a>","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"<a href=\"https:\/\/twitter.com\/LawrenceUni?lang=en\" rel=\"noopener\" target=\"_blank\">https:\/\/twitter.com\/LawrenceUni?lang=en<\/a>","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"<a href=\"https:\/\/www.youtube.com\/results?search_query=lawrence+conservatory\" rel=\"noopener\" target=\"_blank\">https:\/\/www.youtube.com\/results?search_query=lawrence+conservatory<\/a>","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_oembed_5ffa723cbe1d1af4b8e3a58c172f41da%":"<iframe title=\"This is Lawrence - Music Tour with a Mission\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/oEnH3izGY6c?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_5ffa723cbe1d1af4b8e3a58c172f41da%":"1629656410","%_oembed_2d84ffa4519709b5d7cc6f3be27f57f8%":"<iframe title=\"This is Lawrence: A Musical Journey\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/S1gG6TwDilc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_2d84ffa4519709b5d7cc6f3be27f57f8%":"1629656410","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_f925f5cfaba354d5f20776a87022d70b%":"<iframe title=\"Opportunities for Entrepreneurial Musicians\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/LAM6O11dIUI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_f925f5cfaba354d5f20776a87022d70b%":"1690239957","%_oembed_ec506c3fb908c2308e402da966fd2b47%":"<iframe title=\"This is Lawrence - SOL Studios\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/tcl2S7CDE8E?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_ec506c3fb908c2308e402da966fd2b47%":"1690239958","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_48ca43c7d45f5f100c61f31b1bf73601%":"<iframe title=\"Opportunities for Entrepreneurial Musicians\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/LAM6O11dIUI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_48ca43c7d45f5f100c61f31b1bf73601%":"1701547662","%_oembed_e393bb3a3b86bf7c2cf9a0ab1943d6fb%":"<iframe title=\"This is Lawrence - SOL Studios\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/tcl2S7CDE8E?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_e393bb3a3b86bf7c2cf9a0ab1943d6fb%":"1701547662","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"College of Music, Lawrence University, Lawrence University Conservatory of Music, majoring in music, music conservatory, music degrees, music education, music major, music school, School of Music","taxonomy=schools_degrees":"Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Composition &amp; Theory, Minor in music, Music (B.A.), Music Education, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":13483,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"Ithaca College Center for Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ithaca College music orchestra students\" width=\"600\" height=\"408\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Ithaca-College-music-band-students-600x408.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/ithaca-college-center-for-music\/\" class=\"fc-post-link\">Ithaca College Center for Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"953 Danby Rd, Ithaca, NY 14850, United States","location":{"lat":"42.4230656","lng":"-76.49379220000003","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/ithaca-college-center-for-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<h2>The Best of Both Worlds:\r\nA World-Class Center for Music within a Comprehensive College<\/h2>\r\n<strong>Ithaca\u2019s graduates are not only great performers, music educators, composers, and recording technicians, but they are also versatile, adaptable, informed, and can solve complex problems<\/strong>\u2014qualities that are needed to be successful in any field. Exceptional professional training combined with a comprehensive education is a hallmark of the Ithaca experience. With more than 70 majors and 70 minors available at Ithaca College\u2014and over 2,000 courses to choose from\u2014students are exposed to a wide variety of fields of study across five professional schools.\r\n\r\n<strong>The Undergraduate Advantage<\/strong>\r\n\r\nWith 400 undergraduate students and over 60 full-time faculty in music, our students get unparalleled access to a dedicated and accomplished group of scholars, performers, and educators. They experience performance and leadership opportunities in an environment that is as rigorous and challenging as it is nurturing and supportive. Faculty members devote themselves every day to teaching and mentoring our students while maintaining national and international visibility in their fields.\r\n\r\n<strong>Approachable Faculty<\/strong>\r\nOur Center for Music faculty are eager to hear from you. Contact them with specific questions you can\u2019t find answers to on our website. Reach out via email, even before your senior year!\r\n\r\n<strong>Endless Performance Opportunities Include<\/strong>\r\n\u2022 24 ensembles including orchestra, bands, jazz ensembles, and numerous vocal ensembles and chamber groups.\r\n\u2022 Performances in venues including Lincoln Center, Carnegie Hall, and the Kennedy Center.\r\n\u2022 300+ hosted concerts annually on campus.\r\n\r\n<strong>Facilities Second to None<\/strong>\r\nThe Center for Music features three concert halls, four recording studios, two large rehearsal halls, smart classrooms, an Apple computer classroom, labs for jazz and electronic music, and 93 practice rooms. There is also a world-class music education suite, music education library, and resource center. New equipment and capabilities continue to be added each year.\r\n\r\n<strong>Where You\u2019ll Find Ithaca Alumni Working<\/strong>\r\n\u2022 In renowned symphonies, opera companies, and on Broadway;\r\n\u2022 As faculty members and deans in prestigious universities and colleges;\r\n\u2022 As teachers in school systems throughout the country;\r\n\u2022 As music therapists, composers, publicists, audio engineers, and managers;\r\n\u2022 As medical doctors, attorneys, and business professionals who incorporate the many benefits of musical practice into their work and lives.\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/3u3t_8WJ83w?si=KLoeKrOqn-vdW7Z3\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/TeBlBK9KGnA?si=Q86YW_d_yOQCP0Gb\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_column_text]\r\n<p class=\"caption\">Ithaca College Center for Music\u00a0on Tour and in the Classroom<\/p>\r\n[\/vc_column_text][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"25733,25734,25735,25736\" img_size=\"500\" onclick=\"\" css=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"16\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"42.4230656\" lng=\"-76.49379220000003\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14281|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png|caption^null|alt^null|title^markerGreen|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Ithaca College Center for Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/ithaca-college-center-for-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Ithaca College music orchestra students\" width=\"600\" height=\"408\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Ithaca-College-music-band-students-600x408.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Classical Music Students, College of Music, Ithaca College School of Music, major in music, majoring in music, music education, music industry, music school, music schools, music students, musical theatre","%_edit_lock%":"1719355647:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"953 Danby Rd, Ithaca, NY 14850, United States","%_wpgmp_metabox_latitude%":"42.4230656","%_wpgmp_metabox_longitude%":"-76.49379220000003","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Ithaca College School of Music","%_yoast_wpseo_focuskw%":"Ithaca College School of Music","%_yoast_wpseo_metadesc%":"Since its founding in 1892 as a conservatory, the Ithaca College School of Music earns its reputation as one of the best in the nation, offering a superb","%_yoast_wpseo_linkdex%":"62","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"24051","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"21889","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Ithaca College School of Music\" href=\"https:\/\/www.ithaca.edu\/academics\/school-music-theatre-and-dance\" target=\"_blank\" rel=\"noopener\">School of Music, Theatre &amp; Dance Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.ithaca.edu\/academics\/school-music-theatre-and-dance\/undergraduate-majors-and-minors\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a title=\"Ithaca College School of Music faculty\" href=\"https:\/\/www.ithaca.edu\/academics\/school-music-theatre-and-dance\/faculty-and-staff\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Ithaca College music ensembles\" href=\"https:\/\/www.ithaca.edu\/academics\/school-music-theatre-and-dance\/music-admission\/undergraduate-application-process\" target=\"_blank\" rel=\"noopener\">Application Specifics<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.ithaca.edu\/academics\/school-music-theatre-and-dance\/music-admission\/auditions\/requirements-instrument\" target=\"_blank\" rel=\"noopener\">Audition Specifics<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.ithaca.edu\/tuition-financial-aid\/undergraduate-tuition-fees\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.ithaca.edu\/tuition-financial-aid\/undergraduate-costs-financial-aid\" target=\"_blank\" rel=\"noopener\">Financial Aid\/Scholarship Opportunities<\/a><\/li>\r\n \t<li><a title=\"Ithaca College music academy\" href=\"https:\/\/www.ithaca.edu\/summer-music-academy\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.ithaca.edu\/academics\/school-music-theatre-and-dance\/alumni\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.ithaca.edu\/about\/ithaca-college-glance\" target=\"_blank\" rel=\"noopener\">Fast Facts<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_oembed_45bc5828476949943d70691ec901b097%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/RwFIttHKbiE?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_45bc5828476949943d70691ec901b097%":"1463775571","%_oembed_ac6d112169edbf1dcc4997989a6a92ad%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/BLCQbb8DfLs?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_ac6d112169edbf1dcc4997989a6a92ad%":"1463775571","%_yoast_wpseo_content_score%":"30","%ccft_post_comment_title%":"","%easyindexInvalidate%":"1","%_yoast_wpseo_title%":"Ithaca College School of Music - Music Major","%_oembed_d7f3b91d10812a7d18d0f6d17d26d615%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/RwFIttHKbiE?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_d7f3b91d10812a7d18d0f6d17d26d615%":"1492858997","%_oembed_c5ab9f8e0cc92a5e602d711f923e7b52%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/BLCQbb8DfLs?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_c5ab9f8e0cc92a5e602d711f923e7b52%":"1492858997","%_thumbnail_id%":"21888","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"483","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"<a href=\"https:\/\/www.facebook.com\/IthacaMTD\" rel=\"noopener\" target=\"_blank\"><\/a>","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"<a href=\"https:\/\/twitter.com\/i\/flow\/login?redirect_after_login=%2FIthacaMTD\" rel=\"noopener\" target=\"_blank\"><\/a>","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"<a href=\"https:\/\/www.instagram.com\/ithacamtd\/\" rel=\"noopener\" target=\"_blank\"><\/a>","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_f09d02037585cd6218f24a620c706d17%":"<iframe title=\"Ithaca College School of Music - Facility Tour\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/NacNGXPYhjA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_f09d02037585cd6218f24a620c706d17%":"1604777186","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_dc9dfdc016b3dcb80f218255a652ec22%":"<iframe title=\"Announcing the School of Music, Theatre, and Dance | IC News\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/HQGe_c2VdY8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_dc9dfdc016b3dcb80f218255a652ec22%":"1661794340","%_wp_old_slug%":"ithaca-college-school-of-music","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_c26ae0869c067a6a111a35745d233ffd%":"<iframe title=\"Ithaca College Center for Music - Facility Tour\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/NacNGXPYhjA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_c26ae0869c067a6a111a35745d233ffd%":"1701722432","%_oembed_7462b01aedce0429589cce666965b507%":"<iframe title=\"Announcing the School of Music, Theatre, and Dance | IC News\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/HQGe_c2VdY8?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_7462b01aedce0429589cce666965b507%":"1701722432","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_oembed_d4d5d979052d6e9f0bfacab34bab4d44%":"<iframe title=\"Welcome to the Ithaca College School of Music, Theatre, and Dance!\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/3u3t_8WJ83w?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_d4d5d979052d6e9f0bfacab34bab4d44%":"1717019212","%_oembed_0d04074ff0f7ae3c1791145ee8539add%":"<iframe title=\"Whalen Center for Music | Inside IC | Ithaca College\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/TeBlBK9KGnA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_0d04074ff0f7ae3c1791145ee8539add%":"1717019212","%_oembed_49f84aa714b4b50bf756568bd6d89a18%":"{{unknown}}","%tiktok-social%":"<a href=\"https:\/\/www.tiktok.com\/@ithaca.mtd\" rel=\"noopener\" target=\"_blank\"><\/a>","%_tiktok-social%":"field_6658b16ac86cc","taxonomy=post_tag":"Classical Music Students, College of Music, Ithaca College School of Music, major in music, majoring in music, music education, music industry, music school, music schools, music students, musical theatre","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Composition &amp; Theory, Conducting, Music Education, Pedagogy, Performance - Instrumental, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Minor in music, Music (B.A.), Music Education, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":13475,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Indiana University Jacobs School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Indiana University Jacobs School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Indiana-Jacobs-main-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/indiana-university-jacobs-school-music\/\" class=\"fc-post-link\">Indiana University Jacobs School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"205 S Jordan Ave, Bloomington, IN 47405, United States","location":{"lat":"39.1650937","lng":"-86.518284","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/indiana-university-jacobs-school-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\"><strong> The Jacobs School of Music provides distinguished instruction and outstanding opportunities for majors and non-majors to realize their full potential. <\/strong><\/p>\r\nWe foster an equitable and inclusive environment in which students, faculty, and staff have boundless opportunities through creative activity and scholarship at the highest professional levels to shape their own unique paths in the arts.\r\n<ul>\r\n \t<li>175 full-time faculty.<\/li>\r\n \t<li>More than 1,100 performances a year.<\/li>\r\n \t<li>369,000 square feet of facilities.<\/li>\r\n \t<li>More than 75% of students receive scholarships.<\/li>\r\n \t<li>Numerous dual degrees, double majors, and minors offered.<\/li>\r\n \t<li>Six on-campus musical research hubs.<\/li>\r\n \t<li>Over 70 degree programs offered, including new tracks in music industry.<\/li>\r\n \t<li>7:1 student-to-faculty ratio.<\/li>\r\n \t<li>Over 30 ensembles offered.<\/li>\r\n<\/ul>\r\n&nbsp;\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_video link=\"https:\/\/www.youtube.com\/watch?v=jNaUk6p80b0\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"26081,26082,26083,26085\" img_size=\"600x400\" onclick=\"\" css=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"42\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"39.1650937\" lng=\"-86.518284\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14276|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png|caption^null|alt^null|title^markerPurpleNew|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Indiana University Jacobs School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/indiana-university-jacobs-school-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Indiana University Jacobs School of Music\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Indiana-Jacobs-main-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Classical Music Students, Indiana University, Jacobs School of Music, major in music, majoring in music, music education, music industry, music school, music schools, music students, musical theatre","%_edit_lock%":"1725919999:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"205 S Jordan Ave, Bloomington, IN 47405, United States","%_wpgmp_metabox_latitude%":"39.1650937","%_wpgmp_metabox_longitude%":"-86.518284","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Jacobs School of Music","%_yoast_wpseo_focuskw%":"Jacobs School of Music","%_yoast_wpseo_metadesc%":"Indiana University Jacobs School of Music, one of the most comprehensive and acclaimed institutions for the study of music.","%_yoast_wpseo_linkdex%":"51","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"18377","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"26080","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Jacobs School of Music\" href=\"https:\/\/music.indiana.edu\/\" target=\"_blank\" rel=\"noopener\">Jacobs School of Music Homepage<\/a><\/li>\r\n \t<li><a title=\"Indiana University music\" href=\"https:\/\/music.indiana.edu\/degrees-programs\/areas-of-study\/index.html\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a title=\"Indiana University music\" href=\"https:\/\/music.indiana.edu\/faculty\/directory.html\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.indiana.edu\/admissions\/how-to-apply\/index.html\" target=\"_blank\" rel=\"noopener\">Applications\/Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.indiana.edu\/admissions\/financial-aid-costs\/index.html\" target=\"_blank\" rel=\"noopener\">Cost<\/a><\/li>\r\n \t<li><a title=\"Indiana University music\" href=\"https:\/\/music.indiana.edu\/admissions\/financial-aid-costs\/index.html\" target=\"_blank\" rel=\"noopener\">Financial Aid<\/a><\/li>\r\n \t<li><a title=\"Indiana University music\" href=\"https:\/\/music.indiana.edu\/precollege\/summer\/summer-youth-programs\/index.html\" target=\"_blank\" rel=\"noopener\">Summer Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.indiana.edu\/degrees-programs\/areas-of-study\/index.html\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.facebook.com\/IUJSoM\/\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n<\/ul>\r\n<a href=\"https:\/\/www.instagram.com\/iujsom\/?hl=en\"><img class=\"no shadow aligninline wp-image-15806\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2017\/02\/instagram_logo-e1503607373224.png\" alt=\"instagram link\" width=\"32\" height=\"32\" \/><\/a>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"348","%_oembed_234a29c1d6e6be7f4803329b31d04804%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/bmOe0Wp1WFY?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_234a29c1d6e6be7f4803329b31d04804%":"1463773826","%_yoast_wpseo_content_score%":"90","%_oembed_2a625fb9a5d5c06a879be3813c2c8021%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/bmOe0Wp1WFY?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_2a625fb9a5d5c06a879be3813c2c8021%":"1492862366","%easyindexInvalidate%":"1","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_oembed_56d1e145981c07b114bb2d5d8933a660%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ZHPx5jdW9zQ?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_56d1e145981c07b114bb2d5d8933a660%":"1539205067","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_9b500c88447d80f4eff32a5487cf03cf%":"<iframe title=\"For All Who Experience\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ZHPx5jdW9zQ?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_9b500c88447d80f4eff32a5487cf03cf%":"1567721907","%_thumbnail_id%":"26079","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_cd0e9c1ba3e3cdb55377bb1f6e82913c%":"<iframe title=\"For All Who Experience\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ZHPx5jdW9zQ?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_cd0e9c1ba3e3cdb55377bb1f6e82913c%":"1701545638","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_oembed_dd8159435f1edf57ad1c440904704934%":"{{unknown}}","%_oembed_67cc76f1026f2774d4cf9fbb91274b0b%":"<iframe title=\"Join us at the Indiana University Jacobs School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/jNaUk6p80b0?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_67cc76f1026f2774d4cf9fbb91274b0b%":"1725919233","taxonomy=post_tag":"Classical Music Students, Indiana University, Jacobs School of Music, major in music, majoring in music, music education, music industry, music school, music schools, music students, musical theatre","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Chamber Music, Collaborative Piano, Composition &amp; Theory, Conducting, Early Music\/ Historical Performance, Music Education, Musicology, Opera - Directing, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Sacred Music","taxonomy=schools_majors":"Composition &amp; Theory, Early Music\/ Historical Performance, Music Education, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":13468,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"The Hartt School","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Hartt School\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Hartt-lead-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/hartt-school\/\" class=\"fc-post-link\">The Hartt School<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"200 Bloomfield Ave, West Hartford, CT 06117, United States","location":{"lat":"41.794913","lng":"-72.71566940000002","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/hartt-school\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]\r\n<p class=\"intro\"><strong>At Hartt, we prepare you to embark on a lifelong fulfilling career in fields such as commercial music; classical and jazz performance; composing; conducting; music education; music management; production and technology; music history and theory; vocal performance, and more!<\/strong><\/p>\r\nThrough diverse coursework and a close mentoring relationship with faculty, students become versatile and collaborative performing artists, educators, technologists, managers, composers, and scholars.\r\n\r\nWe turn your passion into your profession, and along the way, you can experience some of the following <strong>highlights<\/strong>:\r\n\r\n\u2022 400+ undergraduate students\r\n\r\n\u2022 135 graduate students\r\n\r\n\u2022 85 guest artists a year\r\n\r\n\u2022 400+ performances and masterclasses each year, making Hartt the largest producer of the performing arts in Connecticut\r\n\r\n<strong>Extend Your Reach Beyond Your Major<\/strong>\r\nAs a Hartt student, you receive a world-class performing arts education and have the opportunity to gain so much more. Enhance your educational experience through a minor in an academic discipline outside of the performing arts, take advantage of the University\u2019s Honors Program, find an inspiring internship, or study abroad. You also have the opportunity to join nearly 100 clubs and organizations, attend Division III sporting events, take in gallery shows, or take a day trip into New York City or Boston.\r\n\r\n<strong>Realizing Your Dreams is the Grand Finale<\/strong>\r\nHartt\u2019s dynamic and accomplished alumni are working musicians, dancers, choreographers, actors, singers, educators, technicians, and arts administrators who have earned awards and acclaim around the country and the world.\r\n<blockquote>\u201cI am deeply aware that I would not have this job without the community here that made getting it possible, and I am deeply grateful to my teachers and colleagues. They pushed me to be able to do more and better than I first could dream for myself. Their dreams for me were bigger than mine, and they not only helped me to see that potential, but they also led me there.\u201d<\/blockquote>\r\n<p class=\"quote-citation\">- Chris Ramos, 2023 DMA Instrumental Conducting, Utah Valley University Director of Bands<\/p>\r\n\r\n\r\n<hr \/>\r\n\r\n<b>The Hartt School will host the International Women\u2019s Brass Conference (IWBC) in May, 2025. The event will promote equity and representation in brass music with musicians, educators, and composers from around the world.\u00a0<\/b>\r\n\r\n<hr \/>\r\n\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"http:\/\/www.youtube.com\/watch?v=ERJREG-SnE4\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"http:\/\/www.youtube.com\/watch?v=K-hOkuK-m8c\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"11976,11979,11977,11978\" img_size=\"300x200\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"66\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"41.794913\" lng=\"-72.71566940000002\" zoom=\"12\" scrollwheel=\"disable\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"The Hartt School","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/hartt-school\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"The Hartt School\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Hartt-lead-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, major in music, majoring in music, music auditions, music degree, music degrees, music education, music school, music schools, music students, musical theatre, School of Music, The Hartt School","%_edit_lock%":"1730497963:4","%_edit_last%":"4","%_wpb_vc_js_status%":"false","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"200 Bloomfield Ave, West Hartford, CT 06117, United States","%_wpgmp_metabox_latitude%":"41.794913","%_wpgmp_metabox_longitude%":"-72.71566940000002","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_focuskw_text_input%":"Hartt School","%_yoast_wpseo_focuskw%":"Hartt School","%_yoast_wpseo_metadesc%":"The Hartt School offers comprehensive undergraduate and graduate degree programs and pre-professional training in music, theatre, and dance.","%_yoast_wpseo_linkdex%":"65","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"11982","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"11975","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/www.hartford.edu\/academics\/schools-colleges\/hartt\/default.aspx\" target=\"_blank\" rel=\"noopener\">The Hartt School Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.hartford.edu\/academics\/schools-colleges\/hartt\/academics\/music\/default.aspx\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.hartford.edu\/academics\/schools-colleges\/hartt\/about\/faculty-and-staff\/default.aspx\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.hartford.edu\/academics\/schools-colleges\/hartt\/admission\/apply\/undergraduate.aspx\" target=\"_blank\" rel=\"noopener\">Undergraduate Applications<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.hartford.edu\/academics\/schools-colleges\/hartt\/admission\/apply\/graduate.aspx\" target=\"_blank\" rel=\"noopener\">Graduate Applications<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.hartford.edu\/academics\/schools-colleges\/hartt\/admission\/auditions-and-interviews\/default.aspx\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.hartford.edu\/admission\/scholarships\/default.aspx\" target=\"_blank\" rel=\"noopener\">Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.hartford.edu\/academics\/schools-colleges\/hartt\/career-ready\/success-stories-hartt.aspx\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.hartford.edu\/hartt-community-division\/music\/summer-study\/pre-college-adult.aspx\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_oembed_b3ebdf4d43783888e8d5603f616a293d%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ERJREG-SnE4?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_b3ebdf4d43783888e8d5603f616a293d%":"1463773442","%_oembed_2a49d1f5c2e06b85b05ddbe7591f3ff3%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/K-hOkuK-m8c?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_2a49d1f5c2e06b85b05ddbe7591f3ff3%":"1463773442","%_yoast_wpseo_content_score%":"30","%easyindexInvalidate%":"1","%_wp_old_slug%":"the-hartt-school","%ccft_post_comment_title%":"","%_oembed_cbfa35560468aa6a84f76e6fe7e66196%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ERJREG-SnE4?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_cbfa35560468aa6a84f76e6fe7e66196%":"1492919030","%_oembed_6a3d0127ce4edfb3fc40220a0979f995%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/K-hOkuK-m8c?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_6a3d0127ce4edfb3fc40220a0979f995%":"1492919030","%_yoast_wpseo_title%":"The Hartt School","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"481","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_c5c2eaa789cfaa8c98c629faddb35e4a%":"<iframe title=\"Gerard Schwarz Masterclass at The Hartt School\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/ERJREG-SnE4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_c5c2eaa789cfaa8c98c629faddb35e4a%":"1701543442","%_oembed_405269fffda52a33e3d88cf003fb08f2%":"<iframe title=\"Mentorship at The Hartt School\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/K-hOkuK-m8c?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_405269fffda52a33e3d88cf003fb08f2%":"1701543442","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_thumbnail_id%":"25958","taxonomy=post_tag":"College of Music, major in music, majoring in music, music auditions, music degree, music degrees, music education, music school, music schools, music students, musical theatre, School of Music, The Hartt School","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Composition &amp; Theory, Conducting, Music Education, Musicology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental","taxonomy=schools_majors":"Arts Management, Composition &amp; Theory, Minor in music, Music (B.A.), Music Education, Musicology\/ Music History, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":13465,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Gettysburg College <br\/>Sunderman Conservatory of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Gettysburg College &lt;br\/&gt;Sunderman Conservatory of Music\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/gettysburg-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/gettysburg-college-sunderman-conservatory-of-music\/\" class=\"fc-post-link\">Gettysburg College <br\/>Sunderman Conservatory of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"300 N Washington St, Gettysburg, PA 17325, United States","location":{"lat":"39.8341706","lng":"-77.23368060000001","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/gettysburg-college-sunderman-conservatory-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n<p class=\"intro\"><strong>The Sunderman Conservatory of Music at Gettysburg College offers a Bachelor of Music in Performance, a Bachelor of Music Education, a Bachelor of Arts in Music with the option for a Double Major, and a Minor in Music.<\/strong><\/p>\r\n<span style=\"font-size: 14pt;\"><b>What makes Sunderman unique?<\/b><\/span>\r\n<ul>\r\n \t<li>Professional Conservatory experience within a top liberal arts setting<\/li>\r\n \t<li>Exclusive undergraduate focus<\/li>\r\n \t<li>Numerous opportunities to perform early in your career at Sunderman<\/li>\r\n \t<li>Recent visiting musicians include Erol Josue, Brentano Quartet, Decoda, Imani Winds, eighth blackbird, and Chris Brubeck, to name a few<\/li>\r\n \t<li>Travel with your faculty and perform with your peers in Bali, Prague, Italy, the Baltics, and other locations around the globe<\/li>\r\n \t<li>Accredited by the National Association of Schools of Music (NASM)<\/li>\r\n \t<li>98% placement rate in jobs and graduate schools for recent music graduates<\/li>\r\n \t<li>Close proximity to major performing arts venues in Baltimore (60 mins), Washington, D.C. (80 mins), Philadelphia (2.5 hrs), and New York City (4 hrs)<\/li>\r\n<\/ul>\r\n<span style=\"font-size: 14pt;\"><b>Why Sunderman?<\/b><\/span>\r\n\r\n\u201cI chose Sunderman for the opportunity to double major and for the supportive community. Sunderman offers numerous opportunities to perform and connect with professors because of the undergraduate-only environment. I have grown and developed skills personally and professionally with the help of professors and the supportive community at Sunderman. The opportunity to work so closely with my professors has helped me discover new passions and career paths.\u201d<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\n- <em>Elizabeth Bishop - B.A. in Music, B.S. in Biology<\/em>\r\n\r\n\u201cOur conservatory offers a unique opportunity for creativity and excellence in music within a thriving, broad intellectual environment. For me, to contribute to the world as a musician, one must develop themselves and be well-rounded in all areas of thought. We encourage and empower students to develop as scholars and musicians, allowing them to find their path to contribute to the world. We also offer extensive one-on-one instruction and support that most conservatories cannot provide\u2013my composition students routinely have their works performed by guest ensembles, faculty groups, and peers.\u201d\r\n\r\n- <em>Dr. Avner Dorman - Associate Professor of Music Theory and Composition<\/em>[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_video link=\"https:\/\/www.youtube.com\/watch?v=UYzcNga5mBE\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"16500,16501,16502,16516,16504,16505\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"51\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"39.8341706\" lng=\"-77.23368060000001\" zoom=\"12\" scrollwheel=\"disable\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Gettysburg College <br\/>Sunderman Conservatory of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/gettysburg-college-sunderman-conservatory-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Gettysburg College &lt;br\/&gt;Sunderman Conservatory of Music\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/gettysburg-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, music conservatory, music degrees, music education, School of Music","%_edit_lock%":"1722022667:9","%_edit_last%":"9","%_wpb_vc_js_status%":"true","%_wpgmp_location_address%":"300 N Washington St, Gettysburg, PA 17325, United States","%_wpgmp_metabox_latitude%":"39.8341706","%_wpgmp_metabox_longitude%":"-77.23368060000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"24143","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"10522","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Gettysburg College Music\" href=\"http:\/\/www.gettysburg.edu\/sunderman\" target=\"_blank\" rel=\"noopener\">Homepage<\/a><\/li>\r\n \t<li><a title=\"Gettysburg College Music\" href=\"https:\/\/www.gettysburg.edu\/academic-programs\/sunderman-conservatory\/programs\/\" target=\"_blank\" rel=\"noopener\">Degree Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.gettysburg.edu\/admissions-aid\/fast-facts\" target=\"_blank\" rel=\"noopener\">Gettysburg College Fast Facts<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.gettysburg.edu\/academic-programs\/sunderman-conservatory\/about\/fast-facts\/\" target=\"_blank\" rel=\"noopener\">Sunderman Conservatory Fast Facts<\/a><\/li>\r\n \t<li><a title=\"Gettysburg College Music\" href=\"https:\/\/www.gettysburg.edu\/academic-programs\/sunderman-conservatory\/faculty\/\" target=\"_blank\" rel=\"noopener\">Music Faculty<\/a><\/li>\r\n \t<li><a title=\"Gettysburg College Music\" href=\"https:\/\/www.gettysburg.edu\/admissions-aid\/applying-to-gettysburg\/\" target=\"_blank\" rel=\"noopener\">Application\/Admissions<\/a><\/li>\r\n \t<li><a title=\"Gettysburg College Music\" href=\"https:\/\/www.gettysburg.edu\/academic-programs\/sunderman-conservatory\/audition-information\/\" target=\"_blank\" rel=\"noopener\">Audition Specifics<\/a><\/li>\r\n \t<li><a title=\"Gettysburg College Music\" href=\"https:\/\/www.gettysburg.edu\/admissions-aid\/applying-for-financial-aid\/\" target=\"_blank\" rel=\"noopener\">Scholarship and Aid Information<\/a><\/li>\r\n \t<li><a title=\"Gettysburg College Music\" href=\"https:\/\/www.gettysburg.edu\/news\/stories?id=e843658d-015b-404d-944b-bb3b5b3ac014&amp;pageTitle=What+can+you+do+with+a+music+degree?\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.youtube.com\/c\/SundermanConservatory\" target=\"_blank\" rel=\"noopener\">Visit Our YouTube<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_thumbnail_id%":"25914","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_yoast_wpseo_focuskw_text_input%":"Sunderman Conservatory of Music","%_yoast_wpseo_focuskw%":"Sunderman Conservatory of Music","%_yoast_wpseo_metadesc%":"Sunderman Conservatory of Music is a dedicated place for music inside a liberal arts college, a conservatory embedded in a rich intellectual community.","%_yoast_wpseo_linkdex%":"61","%_oembed_ac219df63a15e3d5390ddc01f45157fc%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/X5CjpGolNZ0?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_ac219df63a15e3d5390ddc01f45157fc%":"1463772644","%_yoast_wpseo_content_score%":"60","%_wp_old_slug%":"sunderman-conservatory-of-music","%easyindexInvalidate%":"1","%_oembed_3201b4e6ae34da8935fbe186689dc3b6%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/X5CjpGolNZ0?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_3201b4e6ae34da8935fbe186689dc3b6%":"1492843959","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"488","%_oembed_345b65834fc927e17f7754be0c84bb8e%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/zpJ3rfsQMSo?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_345b65834fc927e17f7754be0c84bb8e%":"1507833456","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_oembed_59cef893b6e161437c3a8a874c4fa169%":"<iframe title=\"Perform With Us. The Sunderman Conservatory of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/zpJ3rfsQMSo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_59cef893b6e161437c3a8a874c4fa169%":"1567720451","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_079abe38b33463de0309bef76428426f%":"<iframe title=\"Prof. Amanda Heim - The Sunderman Conservatory of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/UYzcNga5mBE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_079abe38b33463de0309bef76428426f%":"1663871491","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_6b70fda41e90c871942116add83b1ecd%":"<iframe title=\"Prof. Amanda Heim - The Sunderman Conservatory of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/UYzcNga5mBE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_6b70fda41e90c871942116add83b1ecd%":"1701545905","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"College of Music, music conservatory, music degrees, music education, School of Music","taxonomy=schools_degrees":"Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Minor in music, Music (B.A.), Music Education, Performance - Instrumental, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":13460,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"DePaul University School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Depaul School of Music lead\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Depaul-music-lead-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/depaul-university-school-of-music\/\" class=\"fc-post-link\">DePaul University School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"804 W Belden Ave, Chicago, IL 60614, United States","location":{"lat":"41.92517970000001","lng":"-87.64943740000001","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/depaul-university-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]<span style=\"font-size: 16pt;\"><b>Create your repertoire for life.<\/b><\/span>\r\n\r\n<span style=\"font-size: 16pt;\">Whether you sing it or teach it. Write it or produce it. You\u2019ll need the training and tools to turn it into a career. <\/span>\r\n\r\nDesigned to be rigorous and collaborative, the DePaul University School of Music programs of study give you the experience and the knowledge to confidently pursue a life dedicated to music.\r\n\r\n<b>Areas of Study<\/b>\r\n\r\nWe offer undergraduate degrees in Performance, Jazz Studies, Music Education, Sound Recording Technology, Performing Arts Management, Composition, a BA in Music; master\u2019s degrees in Performance, Composition, Jazz Studies, Music Education; and a Post-Master\u2019s Performance Certificate.\r\n\r\n<b>Create your repertoire with the best.<\/b>\r\n\r\nOur faculty\u00a0is comprised of over 110 top tier professional musicians who are dedicated to sharing their knowledge and expertise. Not only are they respected and admired educators, but are some of the world's finest and most respected conductors, composers, performers, arts administrators and recording artists, including members of the Chicago Symphony Orchestra, Lyric Opera of Chicago, and Chicago's thriving jazz scene.\r\n\r\n<b>Create your repertoire in unrivaled spaces.<\/b>\r\n\r\nTo build the skills necessary for a career in music, you need a professional space to learn. The kind of space with the look and feel of the great concert halls of the world.Welcome to the Holtschneider Performance Center: Three floors, 185,000 square feet of thoughtfully designed performance, practice, and classroom space. Newly opened this year, the Sasha and Eugene Jarvis Opera Hall, dedicated rehearsal and performance space for vocal studies. Stunning in design and practical in function. A place where every student has the chance to be extraordinary.\r\n\r\n<b>Make Chicago a part of your repertoire.<\/b>\r\n\r\nLocated in Chicago, there\u2019s no better place in the world to study music. Chicago is music. You will hear it everywhere, woven into the fabric of this city with a rich history of diverse sounds.[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/--ALyHH_jP4\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/MSopgE8UcNU\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"21695,21697,21698,21696\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"69\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"41.92517970000001\" lng=\"-87.64943740000001\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14276|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png|caption^null|alt^null|title^markerPurpleNew|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"DePaul University School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/depaul-university-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Depaul School of Music lead\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Depaul-music-lead-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, DePaul University School of Music, jazz students, major in music, majoring in music, Music colleges, music degrees, music industry, music major, music school, music schools, music students, music technology, School of Music","%_edit_lock%":"1632177994:4","%_edit_last%":"4","%_thumbnail_id%":"21692","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"804 W Belden Ave, Chicago, IL 60614, United States","%_wpgmp_metabox_latitude%":"41.92517970000001","%_wpgmp_metabox_longitude%":"-87.64943740000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_metadesc%":"Located in Chicago, the DePaul University School of Music has been a training ground for top performers, music educators, sound engineers, and music business professionals for over 100 years.","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"14209","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"21693","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/music.depaul.edu\/Pages\/default.aspx\" target=\"_blank\" rel=\"noopener\">DePaul University School of Music<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.depaul.edu\/academics\/Pages\/default.aspx\" target=\"_blank\" rel=\"noopener\">Areas of Study\/Majors<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.depaul.edu\/admission\/visit\/Pages\/default.aspx\" target=\"_blank\" rel=\"noopener\">Visit DePaul<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.depaul.edu\/about\/new-facilities\/Pages\/default.aspx\">Holtschneider Performance Center<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.depaul.edu\/faculty-staff\/Pages\/default.aspx\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.depaul.edu\/admission\/application-process\/Pages\/default.aspx\" target=\"_blank\" rel=\"noopener\">Application Specifics<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.depaul.edu\/admission\/auditions\/Pages\/default.aspx\" target=\"_blank\" rel=\"noopener\">Audition Specifics<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.depaul.edu\/admission\/financial-aid\/Pages\/default.aspx\">Tuition and Scholarship Opportunities<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.depaul.edu\/academics\/graduate-programs\/Pages\/default.aspx\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.depaul.edu\/about\/alumni\/Pages\/default.aspx\">Alumni Successes<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.depaul.edu\/resources\/career-services\/Pages\/default.aspx\" target=\"_blank\" rel=\"noopener\">Career Services<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"348","%_oembed_507e5f8c78669a488b0f2299c341c61c%":"{{unknown}}","%_oembed_85cb691470f0e6536ca7b7d29fcf883e%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/09HHtSeHIKA?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_85cb691470f0e6536ca7b7d29fcf883e%":"1463770998","%_oembed_1d242116b3357f04439efbffe65f7de7%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/GDDPqGRNkGM?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_1d242116b3357f04439efbffe65f7de7%":"1463771039","%_yoast_wpseo_focuskw_text_input%":"DePaul University School of Music","%_yoast_wpseo_focuskw%":"DePaul University School of Music","%_yoast_wpseo_linkdex%":"69","%_yoast_wpseo_content_score%":"30","%_oembed_d7a9130147642f7855bb66071716daad%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/GDDPqGRNkGM?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_d7a9130147642f7855bb66071716daad%":"1492841136","%_oembed_92a0e10cb9ff878a242f676dc3a7daba%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/09HHtSeHIKA?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_92a0e10cb9ff878a242f676dc3a7daba%":"1492841136","%easyindexInvalidate%":"1","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"481","%facebook-social%":"<a href=\"https:\/\/www.facebook.com\/depaulschoolofmusic\/\" rel=\"noopener\" target=\"_blank\">https:\/\/www.facebook.com\/depaulschoolofmusic<\/a>","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"<a href=\"https:\/\/twitter.com\/depaulsom\/\" rel=\"noopener\" target=\"_blank\">https:\/\/twitter.com\/depaulsom\/<\/a>","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"<a href=\"https:\/\/www.instagram.com\/depaulsom\" rel=\"noopener\" target=\"_blank\">https:\/\/www.instagram.com\/depaulsom<\/a>","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"<a href=\"https:\/\/www.youtube.com\/user\/depaulSOM\" rel=\"noopener\" target=\"_blank\">https:\/\/www.youtube.com\/user\/depaulSOM<\/a>","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_d667223e29b0cb0c78493f7101f8634e%":"{{unknown}}","%_oembed_300c00cbb88a87d8bbebfc764a0372e8%":"<a class=\"twitter-timeline\" data-width=\"500\" data-height=\"750\" data-dnt=\"true\" href=\"https:\/\/twitter.com\/DePaulSOM?ref_src=twsrc%5Etfw\">Tweets by DePaulSOM<\/a><script async src=\"https:\/\/platform.twitter.com\/widgets.js\" charset=\"utf-8\"><\/script>","%_oembed_time_300c00cbb88a87d8bbebfc764a0372e8%":"1602697622","%_oembed_dd8c4d819d821ce898187eb948fbf92f%":"{{unknown}}","%_oembed_f635c46893872f59b0abf245c4e3e758%":"{{unknown}}","%_oembed_ccbc71d8d93d0e9a2dacac74d9d15875%":"<iframe title=\"DePaul Symphony Orchestra Performs Bruch&#039;s &quot;Scottish Fantasy in E-Flat Major&quot;\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/--ALyHH_jP4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_ccbc71d8d93d0e9a2dacac74d9d15875%":"1602724205","%_oembed_a4ddb685de288877d5794549c906813b%":"<iframe title=\"DePaul Jazz Workshop performs &quot;The Syndicate&quot; by Aaron Lington\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/MSopgE8UcNU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_a4ddb685de288877d5794549c906813b%":"1602724205","%_oembed_325fd193125ffd648219879fcd3d5dd8%":"<iframe title=\"DePaul Symphony Orchestra Performs Bruch&#039;s &quot;Scottish Fantasy in E-Flat Major&quot;\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/--ALyHH_jP4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_325fd193125ffd648219879fcd3d5dd8%":"1602790187","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_771a77ec8639f9374f5dba6b938f61e9%":"<iframe title=\"DePaul Symphony Orchestra Performs Bruch&#039;s &quot;Scottish Fantasy in E-Flat Major&quot;\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/--ALyHH_jP4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_771a77ec8639f9374f5dba6b938f61e9%":"1701545920","%_oembed_1b263673ca7ae04a98b0da75fd4f0363%":"<iframe title=\"DePaul Jazz Workshop performs &quot;The Syndicate&quot; by Aaron Lington\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/MSopgE8UcNU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_1b263673ca7ae04a98b0da75fd4f0363%":"1701545920","taxonomy=post_tag":"College of Music, DePaul University School of Music, jazz students, major in music, majoring in music, Music colleges, music degrees, music industry, music major, music school, music schools, music students, music technology, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Composition &amp; Theory, Music Education, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_majors":"Arts Management, Composition &amp; Theory, Music (B.A.), Music Education, Performance - Instrumental, Performance - Jazz Instrumental, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":13451,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"Colorado State University School of Music, Theatre, and Dance","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Colorado State University School of Music, Theatre, and Dance\" width=\"600\" height=\"340\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/CSU-music-600x340.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/colorado-state-university-department-of-music-theatre-and-dance\/\" class=\"fc-post-link\">Colorado State University School of Music, Theatre, and Dance<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"1400 Remington St, Fort Collins, CO 80524, United States","location":{"lat":"40.5689238","lng":"-105.07445230000002","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/colorado-state-university-department-of-music-theatre-and-dance\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"<p>[vc_row][vc_column][vc_column_text]<\/p>\r\n<p class=\"intro\"><span style=\"font-size: 18px;\"><strong>Thousands of Rams have found their energy at Colorado State University. This is an invitation to find yours!<\/strong><\/span><\/p>\r\n<p>Our goal is to prepare students to become highly skilled <strong>music educators, music therapists, performers, composers, and conductors.<\/strong> Our programs inspire and develop high standards of <strong>teaching, scholarship, performance, and research in music.<\/strong> We are pleased to offer <strong>small academic classes, applied study with highly qualified faculty, and careful attention to advising.<\/strong> You\u2019ll work alongside dynamic faculty and dedicated students, developing knowledge and skills to excel in various fields.<\/p>\r\n<p>The School of Music, Theatre, and Dance represents the performing arts on campus in a highly visible and vibrant environment. <strong>Performance opportunities are extensive,<\/strong> with many orchestras, bands, choirs, jazz ensembles, opera, musical theatre, chamber music, and marching band, while collaborative opportunities draw on art\u2019s <strong>interdisciplinary character.<\/strong><\/p>\r\n<p>At Colorado State University, your training takes place in one of the <strong>nation\u2019s finest teaching and performance facilities,<\/strong> the exquisite University Center for the Arts, where a vibrant learning environment fosters creativity and growth.<\/p>\r\n<p><strong>Degrees<\/strong><br \/>\r\nCSU offers Bachelor of Music (B.M.) concentrations in music education, performance, music therapy, jazz studies, and composition, as well as a Bachelor of Arts in Music and a music minor.<br \/>\r\nA range of M.M. and Ph.D. degrees are also offered, as well as an Arts Management master\u2019s degree.<\/p>\r\n<p><strong>At-a-glance<\/strong><br \/>\r\n\u2022 Collaborative, interdisciplinary projects across the School of Music, Theatre, and Dance<br \/>\r\n\u2022 Ensemble, chamber music, and solo opportunities.<br \/>\r\n\u2022 Scholarships are available for instrumental and vocal performance.<br \/>\r\n\u2022 Small academic class size and weekly lessons with professors.<br \/>\r\n\u2022 Music Therapy program specializes in neuroscience and evidence-based music therapy.<br \/>\r\n\u2022 Auditions for ensembles and musicals are open to all students, regardless of major.<\/p>\r\n<p><strong>Awards and Rankings<\/strong><br \/>\r\n\u2022 National rankings include Forbes\u2019 \u201cAmerica\u2019s Top Colleges\u201d and U.S. News and World Report\u2019s \u201cBest Colleges\u201d and \u201cBest Value Schools.\u201d<br \/>\r\n\u2022 Named the most sustainable university in the U.S. (BestColleges.com, 2015) and maintained Platinum STARS rating.<br \/>\r\n\u2022 Featured in the Smithsonian National Museum of American History\u2019s \u201cPlaces of Invention.\u201d<br \/>\r\n\u2022 Fort Collins consistently ranked as a top place to live (Money Magazine, National Geographic) and \u201cBest Places for Business and Careers\u201d (Forbes).<br \/>\r\n\u2022 CSU is an accredited institutional National Association of Schools of Music (NASM) member.<\/p>\r\n<p>[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']<\/p>\r\n<p><a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/playlist?list=PLfwPamPIwWRCGuR5M9uFakkx-5rfgO75Q\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/dVIy0sUV138?si=FA6s_FGuc_UepvRP\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"26354,26356,26355,26368\" img_size=\"600x400\" onclick=\"\" css=\"\"][vc_column_text]<\/p>\r\n<div id=\"more-information\"><\/div>\r\n<p>[\/vc_column_text][gravityform id=\"5\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"40.5689238\" lng=\"-105.07445230000002\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14280|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png|caption^null|alt^null|title^markerOrange|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]<\/p>\r\n","post_title":"Colorado State University School of Music, Theatre, and Dance","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/colorado-state-university-department-of-music-theatre-and-dance\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Colorado State University School of Music, Theatre, and Dance\" width=\"600\" height=\"340\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/CSU-music-600x340.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Classical Music Students, Colorado State University, major in music, majoring in music, music education, music industry, music school, music schools, music students, musical theatre, Theatre and Dance","%_edit_lock%":"1731979002:4","%_edit_last%":"4","%_thumbnail_id%":"26349","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"1400 Remington St, Fort Collins, CO 80524, United States","%_wpgmp_metabox_latitude%":"40.5689238","%_wpgmp_metabox_longitude%":"-105.07445230000002","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"4\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"26350","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"26351","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Department of Music Colorado State University\" href=\"https:\/\/music.colostate.edu\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.colostate.edu\/academics\/undergraduate\/\" target=\"_blank\" rel=\"noopener\">Music Undergraduate Degrees<\/a><\/li>\r\n \t<li><a title=\"Colorado State University graduate programs\" href=\"https:\/\/music.colostate.edu\/academics\/graduate\/\" target=\"_blank\" rel=\"noopener\">Music Graduate Degrees<\/a><\/li>\r\n \t<li><a title=\"music faculty colorado state univ.\" href=\"https:\/\/music.colostate.edu\/people\/\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"music auditions colorado state university\" href=\"https:\/\/music.colostate.edu\/admissions\/undergrad-apply\/\" target=\"_blank\" rel=\"noopener\">CSU Undergraduate Apply\/Audition<\/a><\/li>\r\n \t<li><a title=\"music auditions colorado state university\" href=\"https:\/\/music.colostate.edu\/admissions\/grad-apply\/\" target=\"_blank\" rel=\"noopener\">CSU Graduate Apply\/Audition<\/a><\/li>\r\n \t<li><a href=\"https:\/\/financialaid.colostate.edu\/cost-of-attendance\/\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/financialaid.colostate.edu\" target=\"_blank\" rel=\"noopener\">CSU Scholarships and Financial Aid<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.colostate.edu\/admissions\/undergrad-scholarships\/\" target=\"_blank\" rel=\"noopener\">Music Undergraduate Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.colostate.edu\/admissions\/grad-scholarships\/\" target=\"_blank\" rel=\"noopener\">Music Graduate Assistantships and Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/music.colostate.edu\/masterclasses-camps\/\" target=\"_blank\" rel=\"noopener\">Masterclasses, Camps, and Special Events<\/a><\/li>\r\n \t<li><a href=\"https:\/\/career.colostate.edu\/what-we-do\/\" target=\"_blank\" rel=\"noopener\">Career Center<\/a><\/li>\r\n \t<li><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"351","%_oembed_3a77c3c065da9ca2da078009a5f0dcd7%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/bMPIInYyVsI?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_3a77c3c065da9ca2da078009a5f0dcd7%":"1463768726","%_yoast_wpseo_metadesc%":"\"Our primary goal at Colorado State University School of Music, Theatre and Dance is to prepare students to become highly skilled music educators, music therapists, performers, composers and conductors.","%_yoast_wpseo_focuskw_text_input%":"Colorado State University Department of Music, Theatre and Dance","%_yoast_wpseo_focuskw%":"Colorado State University School of Music, Theatre and Dance","%_yoast_wpseo_linkdex%":"59","%_yoast_wpseo_content_score%":"30","%_oembed_879547bd614f7a425566d750e9cd4550%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/bMPIInYyVsI?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_879547bd614f7a425566d750e9cd4550%":"1492845862","%easyindexInvalidate%":"1","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"483","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wp_old_slug%":"csu-department-of-music-theatre-and-dance","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_4285babaa992507381aa6150654a5577%":"<iframe title=\"Ramble On: &quot;The Gondoliers&quot; Brings Comic Opera to Colorado State University\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/bMPIInYyVsI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_4285babaa992507381aa6150654a5577%":"1701556190","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_oembed_a8e07b14f2a960c4bc4f7e3c7fb58187%":"{{unknown}}","%_oembed_3068a436a0473e91b8334a7ee9589d34%":"{{unknown}}","%_oembed_e8aaccab5cd6695453f35d486e97ff0c%":"<iframe title=\"2024-2025 Colorado All-State Instructional Videos\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/videoseries?list=PLfwPamPIwWRCGuR5M9uFakkx-5rfgO75Q\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_e8aaccab5cd6695453f35d486e97ff0c%":"1731613233","%_oembed_74565754a9e2863020172df1d20a5166%":"<iframe title=\"2-Minute Tour: University Center for the Arts\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/dVIy0sUV138?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_74565754a9e2863020172df1d20a5166%":"1731613234","taxonomy=post_tag":"Classical Music Students, Colorado State University, major in music, majoring in music, music education, music industry, music school, music schools, music students, musical theatre, Theatre and Dance","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Arts Management, Composition &amp; Theory, Conducting, Music Education, Music Therapy, Performance - Instrumental, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Minor in music, Music (B.A.), Music Education, Music Therapy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Vocal","taxonomy=schools_Region":"Western US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png"},"id":13448,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png","name":"Western US Music Schools","id":"3","type":"category"}]},{"source":"post","title":"Chicago College of Performing Arts at Roosevelt University","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chicago College of Performing Arts at Roosevelt University\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/rooseveltnew-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/chicago-college-of-performing-arts-roosevelt-university\/\" class=\"fc-post-link\">Chicago College of Performing Arts at Roosevelt University<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"430 S Michigan Ave, Chicago, IL 60605, United States","location":{"lat":"41.87599580000001","lng":"-87.62485509999999","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/chicago-college-of-performing-arts-roosevelt-university\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]Music is a calling, and preparing for a life in music requires an unwavering desire to achieve mastery of one\u2019s craft. Music majors arrive Chicago College of Performing Arts at Roosevelt University with artistic desire, and leave with the skills and knowledge to begin a life in music. Studio lessons, recitals, chamber music, operas, and jazz combos form the nucleus of a performer's training at CCPA.\r\n\r\nOne of the oldest Music Conservatories in the United States, the Chicago College of Performing Arts at Roosevelt University provides students the opportunity to study with world-renowned artists in the heart of one of the nation\u2019s greatest cities. The\u00a0 Music Conservatory faculty includes members of the Chicago Symphony and Lyric Opera Orchestras, Metropolitan and Lyric Opera stars, Grammy award-winning jazz artists, and other internationally-recognized professionals. Our teacher-artists provide their students with one-on-one instruction, technical expertise, and an inspiring love of music.\r\n\r\nThe students of CCPA study in the midst of Chicago's invigorating arts scene, and acquire additional experience through internships with nationally-known music companies. They watch world-renowned conductors lead the Chicago Symphony, enjoy outdoor performances at Pritzker Pavilion in Millennium Park, witness premieres of new works in Chicago's thriving contemporary music scene, and see American legends performing at the famous Jazz Showcase. Studying in the heart of one of the nation's greatest cities gives our students a leg up on creating a strong network of professional contacts and a head start on the career they envision.\r\n\r\nThe alumni of CCPA's Music Conservatory are part of a lively continuum of achievement, performing with major ensembles and finding success as educators, conductors, composers, and critics.\r\n\r\nThe Music Conservatory of CCPA offers BM, MM, and Diploma degrees in Classical Performance, Jazz &amp; Contemporary Music Studies, Music Education, and Orchestral Studies. [\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner][vc_video link=\"https:\/\/vimeo.com\/136834502?\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"9079,12169,12170,9083\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"37\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"41.87599580000001\" lng=\"-87.62485509999999\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14276|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png|caption^null|alt^null|title^markerPurpleNew|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Chicago College of Performing Arts at Roosevelt University","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/chicago-college-of-performing-arts-roosevelt-university\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Chicago College of Performing Arts at Roosevelt University\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/rooseveltnew-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Chicago College of Performing Arts, contemporary music, jazz, major in music, majoring in music, music business, music education, music industry, music school, music schools, music students, musical theatre, popular music, Roosevelt University","%_edit_lock%":"1721095642:9","%_edit_last%":"9","%_thumbnail_id%":"25892","%_wpb_vc_js_status%":"false","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"430 S Michigan Ave, Chicago, IL 60605, United States","%_wpgmp_metabox_latitude%":"41.87599580000001","%_wpgmp_metabox_longitude%":"-87.62485509999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"2\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"6\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"9094","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"12168","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Roosevelt University\" href=\"http:\/\/www.roosevelt.edu\/ccpa\" target=\"_blank\" rel=\"noopener\">Homepage - Chicago College of Performing Arts<\/a><\/li>\r\n \t<li><a title=\"Roosevelt University\" href=\"https:\/\/www.roosevelt.edu\/academics\/programs?plcheader_1%24chkCCPA=on&amp;FilterByCollege=Choose+Program+By+College\" target=\"_blank\" rel=\"noopener\">Majors Offered and Degree Programs<\/a><\/li>\r\n \t<li><a title=\"Roosevelt University\" href=\"https:\/\/www.roosevelt.edu\/contact\/directory\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Roosevelt University\" href=\"https:\/\/www.roosevelt.edu\/admission\/ccpa\" target=\"_blank\" rel=\"noopener\">Applications &amp; Auditions<\/a><\/li>\r\n \t<li><a title=\"Roosevelt University\" href=\"https:\/\/www.roosevelt.edu\/tuition-aid\/tuition\" target=\"_blank\" rel=\"noopener\">Tuition<\/a><\/li>\r\n \t<li><a title=\"Roosevelt University\" href=\"https:\/\/www.roosevelt.edu\/invest-your-future\" target=\"_blank\" rel=\"noopener\">Scholarships &amp; Financial Aid<\/a><\/li>\r\n \t<li><a title=\"Roosevelt University\" href=\"https:\/\/www.roosevelt.edu\/colleges\/ccpa\/music-conservatory\/music-student-achievements\" target=\"_blank\" rel=\"noopener\">Alumni Achievements<\/a><\/li>\r\n \t<li><a class=\"\" href=\"https:\/\/www.roosevelt.edu\/colleges\/ccpa\/experience-ccpa\" target=\"_blank\" rel=\"noopener\">CCPA Experience Day<\/a><\/li>\r\n \t<li><a class=\"\" href=\"https:\/\/www.roosevelt.edu\/colleges\/ccpa\/summer\" target=\"_blank\" rel=\"noopener\">CCPA Summer<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"348","%_oembed_eb23218cb61a8c3886b2370314f742a4%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/136834502\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"I&#039;m Prepared\" webkitallowfullscreen mozallowfullscreen allowfullscreen><\/iframe>","%_oembed_time_eb23218cb61a8c3886b2370314f742a4%":"1463766851","%_yoast_wpseo_metadesc%":"Chicago College of Performing Arts at Roosevelt University provides students the opportunity to study with world-renowned artists in the heart of Chicago.","%_yoast_wpseo_focuskw_text_input%":"Chicago College of Performing Arts at Roosevelt University","%_yoast_wpseo_focuskw%":"Chicago College of Performing Arts at Roosevelt University","%_yoast_wpseo_linkdex%":"69","%_yoast_wpseo_content_score%":"30","%_wp_old_slug%":"roosevelt-university","%easyindexInvalidate%":"1","%_oembed_64a48361765e623bf1cba144050f5c83%":"<iframe src=\"https:\/\/player.vimeo.com\/video\/136834502\" width=\"500\" height=\"281\" frameborder=\"0\" title=\"I&#039;m Prepared\" webkitallowfullscreen mozallowfullscreen allowfullscreen><\/iframe>","%_oembed_time_64a48361765e623bf1cba144050f5c83%":"1492857856","%ccft_post_comment_title%":"","%_yoast_wpseo_title%":"Chicago College of Performing Arts at Roosevelt University","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_e49721582ae8fee59b4dbc303477e65b%":"<iframe title=\"I&#039;m Prepared\" src=\"https:\/\/player.vimeo.com\/video\/136834502?dnt=1&amp;app_id=122963\" width=\"500\" height=\"281\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture\"><\/iframe>","%_oembed_time_e49721582ae8fee59b4dbc303477e65b%":"1701545916","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"Chicago College of Performing Arts, contemporary music, jazz, major in music, majoring in music, music business, music education, music industry, music school, music schools, music students, musical theatre, popular music, Roosevelt University","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Arts Management, Composition &amp; Theory, Performance - Instrumental, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Music Education, Musical Theatre, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal","taxonomy=schools_Region":"Central US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"},"id":13446,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png","name":"Central US Music Schools","id":"6","type":"category"}]},{"source":"post","title":"Carnegie Mellon University School of Music","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Carnegie Mellon School of Music\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Carnegie-Mellon-School-of-Music-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/carnegie-mellon-school-of-music\/\" class=\"fc-post-link\">Carnegie Mellon University School of Music<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"5000 Forbes Ave, Pittsburgh, PA 15213, United States","location":{"lat":"40.4438782","lng":"-79.94199200000003","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/carnegie-mellon-school-of-music\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"<p>[vc_row][vc_column][\/vc_column][\/vc_row][vc_row][vc_column][vc_column_text]<span style=\"font-size: 18pt;\"><b>Where artistry + innovation share center stage<\/b><\/span><\/p>\r\n<p>Becoming a professional musician requires talent and commitment. It also takes the right education environment: <b>Carnegie Mellon School of Music<\/b><\/p>\r\n<p><span style=\"font-size: 14pt;\"><b>Who We Are<\/b><\/span><\/p>\r\n<p>Founded in 1912 as one of the five schools of the College of Fine Arts, Carnegie Mellon School of Music offers conservatory-level programs within a world-class university environment.<\/p>\r\n<p><span style=\"font-size: 14pt;\"><b>What We Offer<\/b><\/span><\/p>\r\n<p>Undergraduate<br \/>\r\n<i>Bachelor of Fine Arts<\/i><\/p>\r\n<ul>\r\n<li>Instrumental Performance, Keyboard Performance, Vocal Performance, Composition, Electronic Music<\/li>\r\n<\/ul>\r\n<p><i>Bachelor of Science in Music &amp; Technology<\/i><\/p>\r\n<ul>\r\n<li>In collaboration with the School of Computer Science and the Department of Electrical and Computer Engineering<\/li>\r\n<\/ul>\r\n<p><i>BXA Intercollege Degrees<\/i><\/p>\r\n<ul>\r\n<li>Students in BXA programs have a concentration in music and in the second college. Music Concentrations include:\r\n<ul>\r\n<li><i>Performance (instrumental, keyboard, voice)<\/i><\/li>\r\n<li><i>Composition<\/i><\/li>\r\n<li><i>Musicology &amp; Cultural Studies<\/i><\/li>\r\n<li><i>Technology<\/i><\/li>\r\n<\/ul>\r\n<\/li>\r\n<li><i>Bachelor of Humanities and Arts: <\/i>In collaboration with the Dietrich College of Humanities<\/li>\r\n<li><i>Bachelor of Science and Arts: <\/i>In collaboration with the Mellon College of Science<\/li>\r\n<li><i>Bachelor of Computer Science and Arts: <\/i>In collaboration with the School of Computer Science<\/li>\r\n<\/ul>\r\n<p><i>Minors for Music Majors<\/i><\/p>\r\n<ul>\r\n<li>Collaborative Piano, Conducting, Music Education Certification, Music Technology, Music Theory<\/li>\r\n<\/ul>\r\n<p>Graduate, Advanced Music Studies Certificate, and Artist Diploma programs are available.<\/p>\r\n<p><span style=\"font-size: 14pt;\"><b>Why Carnegie Mellon<\/b><\/span><\/p>\r\n<ul>\r\n<li>Be a part of an <b>innovative fine arts community<\/b> immersed in a top research university.<\/li>\r\n<li>We offer the <b>best aspects<\/b> of a conservatory (small class size, individual attention, and creative opportunity) along with experiences only a university can offer (double majors, extensive student organizations, and uniquely CMU traditions).<\/li>\r\n<li>From performance ensembles and opera productions to chamber music and recitals, the School of Music has over 250 events each year.<\/li>\r\n<li>All music courses and lessons are <b>taught by faculty members<\/b>, not graduate students.<\/li>\r\n<li><b>Pittsburgh<\/b> is home to a dynamic arts, culture, and technology community.<\/li>\r\n<li><b>20 members<\/b> on the School of Music\u2019s faculty are members of the world-renowned Pittsburgh Symphony Orchestra.<\/li>\r\n<\/ul>\r\n<p><span style=\"font-size: 14pt;\"><b>Alumni<\/b><\/span><\/p>\r\n<p>Our alumni are performers, teachers, conductors, and entrepreneurs working in creative industries across the globe. They populate the ranks of the world\u2019s most prestigious orchestras, opera companies, and conservatory faculties including the New York Philharmonic, The Metropolitan Opera, Pittsburgh Symphony Orchestra, Harvard University, BBC Orchestras, Lyric Opera of Chicago and many more.<\/p>\r\n<hr \/>\r\n<blockquote><p>A very special kind of young musician populates the School of Music at Carnegie Mellon University. The students here are intelligent, curious, ambitious and energetic, with musical talent in abundance. Each time I encounter them - in class, in rehearsal, or in the hallways \u2013 I am grateful that the future of our art is in such good hands.\u201d<\/p><\/blockquote>\r\n<p class=\"quote-citation\">Denis Colwell, Retired Head of the School of Music<\/p>\r\n<p>[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']<\/p>\r\n<p><a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/_s08leKKJFM?feature=shared\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/coCP3wO8Gxo?feature=shared\" css=\"\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"21357,21358,22823,21360\" img_size=\"600x400\" onclick=\"\"][vc_column_text]<\/p>\r\n<div id=\"more-information\"><\/div>\r\n<p>[\/vc_column_text][gravityform id=\"49\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"40.4438782\" lng=\"-79.94199200000003\" zoom=\"12\" scrollwheel=\"disable\" infowindow_open=\"off\" marker_icon=\"custom\" icon_img=\"id^14281|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png|caption^null|alt^null|title^markerGreen|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]<\/p>\r\n","post_title":"Carnegie Mellon University School of Music","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/carnegie-mellon-school-of-music\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Carnegie Mellon School of Music\" width=\"600\" height=\"399\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Carnegie-Mellon-School-of-Music-600x399.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Carnegie Mellon University School of Music, Carnegie Mellon Univesity, College of Music, major in music, music education, music school, music schools, School of Music","%_edit_lock%":"1736994778:4","%_edit_last%":"9","%_thumbnail_id%":"21355","%_wpb_vc_js_status%":"true","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"5000 Forbes Ave, Pittsburgh, PA 15213, United States","%_wpgmp_metabox_latitude%":"40.4438782","%_wpgmp_metabox_longitude%":"-79.94199200000003","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_wp_old_slug%":"carnegie-mellon-university-school-music","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"19790","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"19792","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a title=\"Carnegie Mellon University School of Music\" href=\"https:\/\/www.cmu.edu\/cfa\/music\/\" target=\"_blank\" rel=\"noopener\">Music School Home Page<\/a><\/li>\r\n \t<li><a title=\"Carnegie Mellon University School of Music\" href=\"https:\/\/www.cmu.edu\/cfa\/music\/programs\/index.html\" target=\"_blank\" rel=\"noopener\">Majors Offered<\/a><\/li>\r\n \t<li><a title=\"Carnegie Mellon University School of Music\" href=\"https:\/\/www.cmu.edu\/cfa\/music\/people\/index.html\" target=\"_blank\" rel=\"noopener\">Faculty<\/a><\/li>\r\n \t<li><a title=\"Carnegie Mellon University School of Music\" href=\"https:\/\/www.cmu.edu\/cfa\/music\/apply\/index.html\" target=\"_blank\" rel=\"noopener\">Application to School of Music<\/a><\/li>\r\n \t<li><a href=\"https:\/\/admission.enrollment.cmu.edu\/pages\/undergraduate-admission-requirements\" target=\"_blank\" rel=\"noopener\">University Application<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cmu.edu\/cfa\/music\/apply\/audition-portfolio-review\/index.html\" target=\"_blank\" rel=\"noopener\">Audition Information<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cmu.edu\/cfa\/music\/preparatory-summer-programs\/preparatory-school\/tuition-and-financial-aid.html\" target=\"_blank\" rel=\"noopener\">Tuition &amp; Fees<\/a><\/li>\r\n \t<li><a title=\"Carnegie Mellon University School of Music\" href=\"https:\/\/www.cmu.edu\/cfa\/music\/apply\/financial-aid.html\" target=\"_blank\" rel=\"noopener\">Financial Aid\/Scholarships<\/a><\/li>\r\n \t<li><a title=\"Carnegie Mellon University School of Music\" href=\"https:\/\/www.cmu.edu\/pre-college\/academic-programs\/music.html#curriculum\" target=\"_blank\" rel=\"noopener\">Summer Pre-College<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cmu.edu\/cfa\/music\/programs\/graduate-programs\/index.html\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cmu.edu\/cfa\/music\/current-students\/career-resources\/index.html\" target=\"_blank\" rel=\"noopener\">Music Career Resources<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cmu.edu\/cfa\/music\/news\/index.html\" target=\"_blank\" rel=\"noopener\">School of Music News<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.cmu.edu\/cfa\/music\/apply\/faqs.html\" target=\"_blank\" rel=\"noopener\">FAQ<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_oembed_f5be516dd53d366813c684c7fc945c74%":"{{unknown}}","%_yoast_wpseo_metadesc%":"A Carnegie Mellon School of Music education prepares gifted students to make an impact on the art of music in the 21st century. The School of Music offers conservatory programs within a world-class university.","%_yoast_wpseo_focuskw_text_input%":"Carnegie Mellon University School of Music","%_yoast_wpseo_focuskw%":"Carnegie Mellon School of Music","%_yoast_wpseo_linkdex%":"67","%_yoast_wpseo_content_score%":"60","%easyindexInvalidate%":"1","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"548","%_yoast_wpseo_primary_schools_majors%":"482","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"<a href=\"https:\/\/www.youtube.com\/user\/CarnegieMellonMusic\/videos\" rel=\"noopener\" target=\"_blank\">https:\/\/www.youtube.com\/channel\/UCBiMT6bXnGsWfFzAhkJ_kxQ<\/a>","%_youtube-social%":"field_5d1d21d597bfc","%_yoast_wpseo_title%":"%%title%% %%page%% %%sep%% music major","%_oembed_337ad8d6c17b24a2357848205e240424%":"<iframe title=\"Tour of the Carnegie Mellon School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/_s08leKKJFM?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_337ad8d6c17b24a2357848205e240424%":"1597794204","%_oembed_2457ed2c824d8a8a55466be039bc5c76%":"<iframe title=\"Carnegie Mellon Philharmonic - Brahms: Symphony No 2 in D Major Op 73\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/coCP3wO8Gxo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_2457ed2c824d8a8a55466be039bc5c76%":"1597794205","%_oembed_18e9ce80752af76700417b3b5ea398c9%":"{{unknown}}","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_yoast_wpseo_wordproof_timestamp%":"","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_6bcd91dee8fb37b10545a13944996ba3%":"<iframe title=\"Tour of the Carnegie Mellon School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/_s08leKKJFM?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_6bcd91dee8fb37b10545a13944996ba3%":"1701547562","%_oembed_2b3a000f3a2a4f63e3e45b351dc64f7a%":"<iframe title=\"Carnegie Mellon Philharmonic - Brahms: Symphony No 2 in D Major Op 73\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/coCP3wO8Gxo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_2b3a000f3a2a4f63e3e45b351dc64f7a%":"1701547562","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","%_oembed_b437503af360a690f1b6a0f6df3825d7%":"{{unknown}}","%_oembed_2ca86d3ff6eeb1fed8a4ab73c493cc2d%":"{{unknown}}","%_oembed_85470215c6d87657e675a49e492804b2%":"{{unknown}}","%_oembed_acb1752c9ca88f8b810fc3b1a9383b87%":"{{unknown}}","%_oembed_dab594f02414467388a2e7463c8b252b%":"<iframe title=\"Tour of the Carnegie Mellon School of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/_s08leKKJFM?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_dab594f02414467388a2e7463c8b252b%":"1736994490","%_oembed_482a4917207f90ddecfe29f2a0fd6059%":"<iframe title=\"Carnegie Mellon Philharmonic - Brahms: Symphony No 2 in D Major Op 73\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/coCP3wO8Gxo?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_482a4917207f90ddecfe29f2a0fd6059%":"1736994539","taxonomy=post_tag":"Carnegie Mellon University School of Music, Carnegie Mellon Univesity, College of Music, major in music, music education, music school, music schools, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Music Education, Music Entrepreneurship, Music Technology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/Production\/Engineering","taxonomy=schools_majors":"Collaborative Piano, Composition &amp; Theory, Electronic Music, Minor in music, Music Education, Music Entrepreneurship, Music Technology, Pedagogy, Performance - Instrumental, Performance - Jazz Instrumental, Performance - Jazz Vocal, Performance - Vocal, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":13443,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Boston Conservatory at Berklee","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Boston Conservatory at Berklee\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Boston-Conservatory-at-Berklee-cello-student-1-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/boston-conservatory\/\" class=\"fc-post-link\">Boston Conservatory at Berklee<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Boston Conservatory, Fenway, Boston, MA, United States","location":{"lat":"42.3461639","lng":"-71.09004270000003","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/boston-conservatory\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text]\r\n\r\n<span style=\"font-size: 14pt;\"><strong>Boston Conservatory at Berklee\u2019s Music Division offers a reimagined approach to classical music training that reflects and engages with the world we live in. By embracing diversity\u2014of people, perspective, and aesthetic\u2014our students are prepared to both impact the world now and shape tomorrow\u2019s musical landscape.<\/strong><\/span>\r\n\r\n<strong>Music Majors at Boston Conservatory:<\/strong>\r\n\r\n\u2022 Brass Performance\r\n\r\n\u2022 Choral Conducting\r\n\r\n\u2022 Collaborative Piano\r\n\r\n\u2022 Composition\r\n\r\n\u2022 Piano Performance\r\n\r\n\u2022 Contemporary Classical Music Performance\r\n\r\n\u2022 Harp Performance\r\n\r\n\u2022 Conducting\r\n\r\n\u2022 Percussion \/ Marimba Performance\r\n\r\n\u2022 String Performance\r\n\r\n\u2022 Vocal Pedagogy\u2014Classical Voice\r\n\r\n\u2022 Vocal Pedagogy\u2014Musical Theater Voice\r\n\r\n\u2022 Voice and Opera Performance\r\n\r\n\u2022 Woodwind Performance\r\n\r\n<em>Boston Conservatory also offers B.F.A. programs in musical theater and contemporary theater through its Theater Division. <a href=\"https:\/\/cloud.info.berklee.edu\/theater?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-listing\" target=\"_blank\" rel=\"noopener\">Learn more<\/a>.<\/em>\r\n\r\nBoston Conservatory\u2019s distinguished music faculty are acclaimed nationally and internationally. Offering real world experience and expertise, our faculty help our students create professional connections and empower them to cultivate original artistic expression. With an <strong>emphasis on contemporary classicism and the art music of the future<\/strong>, our students are equipped with the versatility and entrepreneurial mindset needed to carve their own career paths. As leaders and radical innovators, <strong>Boston Conservatory graduates are artist-citizens who use their creative platform to change the world for the better.<\/strong>\r\n\r\nAs part of the larger Berklee organization, Boston Conservatory music students have access to more than 250 courses through Berklee College of Music, such as Music Business, Technology, Film Scoring, Recording Engineering, Songwriting, and more. In addition, students can chose a minor from dozens of subject areas including Acoustics and Electronics, Africana Studies, American Roots Music, Creative Entrepreneurship, Game and Interactive Media Scoring, Gender Studies, Microtonal Music, Global Studies, Music Technology, Philosophy, Private Studio Teaching, Psychology, and Recording and Production for Musicians to name a few.\r\n<p class=\"intro\"><span style=\"font-size: 16px;\">[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']<\/span><\/p>\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=Ege8VTVQ-jk\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/9_FBGAdlFSE\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"21707,21708,21709,21710\" img_size=\"600x400\" onclick=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"11\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"42.3461639\" lng=\"-71.09004270000003\" zoom=\"12\" scrollwheel=\"disable\" infowindow_open=\"off\" marker_icon=\"custom\" icon_img=\"id^14281|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png|caption^null|alt^null|title^markerGreen|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Boston Conservatory at Berklee","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/boston-conservatory\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Boston Conservatory at Berklee\" width=\"600\" height=\"400\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/Boston-Conservatory-at-Berklee-cello-student-1-600x400.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"Boston Conservatory, Boston Conservatory at Berklee, College of Music, major in music, majoring in music, music conservatory, music degrees, music education, music major, music school, music schools, music students, School of Music","%_edit_lock%":"1732134960:4","%_edit_last%":"4","%_wpb_vc_js_status%":"false","%_wpb_shortcodes_custom_css%":".vc_custom_1463694336621{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_wpgmp_location_address%":"Boston Conservatory, Fenway, Boston, MA, United States","%_wpgmp_metabox_latitude%":"42.3461639","%_wpgmp_metabox_longitude%":"-71.09004270000003","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"3\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%category_sticky_post%":"0","%school_logo%":"16892","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"21712","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/music\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/music#:~:text=Explore%20Our%20Programs\" target=\"_blank\" rel=\"noopener\">Majors and Graduate Programs Offered<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/faculty?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-music-faculty\" target=\"_blank\" rel=\"noopener\">Music Faculty<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/admissions\/application-steps?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-application-process\" target=\"_blank\" rel=\"noopener\">Application Process<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/admissions\/audition-process?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-audition-process\" target=\"_blank\" rel=\"noopener\">Audition Process<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/news\" target=\"_blank\" rel=\"noopener\">Alumni Highlights<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/offices-and-services\/cost-attendance?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-listing-cost\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/financial-aid?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-tuition-scholarships\" target=\"_blank\" rel=\"noopener\">Tuition &amp; Scholarships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/music\/partnerships?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-professional-partnerships\" target=\"_blank\" rel=\"noopener\">Professional Partnerships<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/summer?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-summer-music-programs\" target=\"_blank\" rel=\"noopener\">Summer Music Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/music?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-graduate-programs\" target=\"_blank\" rel=\"noopener\">Graduate Programs<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.berklee.edu\/career-center?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-berklee-career-center\" target=\"_blank\" rel=\"noopener\">Berklee Career Center<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/diversity-and-inclusion?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-diversity-and-inclusion-values\" target=\"_blank\" rel=\"noopener\">Diversity and Inclusion Values<\/a><\/li>\r\n \t<li><a href=\"https:\/\/bostonconservatory.berklee.edu\/international-student-services?campaign_id=7010Z000001ZkQMQA0&amp;utm_source=majoring-in-music&amp;utm_medium=partner&amp;utm_campaign=bcb-gen-partner-international-students\" target=\"_blank\" rel=\"noopener\">International Students<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%_yoast_wpseo_primary_schools_Region%":"349","%_oembed_c73b9bbddf8dccf5835d1adaf16b8ccc%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/uWNODmWTS2w?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_c73b9bbddf8dccf5835d1adaf16b8ccc%":"1463695602","%_oembed_cb352a8144789632ad54c8141e0e9da0%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/PQAUOHqa_s0?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_cb352a8144789632ad54c8141e0e9da0%":"1463695602","%_yoast_wpseo_metadesc%":"Founded in 1867, Boston Conservatory at Berklee is the nation\u2019s oldest and most historic performing arts conservatory that offers fully accredited undergrad","%_yoast_wpseo_focuskw_text_input%":"Boston Conservatory","%_yoast_wpseo_focuskw%":"Boston Conservatory","%_yoast_wpseo_linkdex%":"71","%_yoast_wpseo_content_score%":"30","%easyindexInvalidate%":"1","%_yoast_wpseo_title%":"Boston Conservatory at Berklee - Music Major","%_wp_old_slug%":"the-boston-conservatory","%_oembed_b31cebf3d1ae4e514ffa418ea1913f00%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/5ECK4O20Fmk?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_b31cebf3d1ae4e514ffa418ea1913f00%":"1472084565","%_oembed_46eebb6cec61f1078f06ca4326f61c36%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/kKy9gPMC8hA?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_46eebb6cec61f1078f06ca4326f61c36%":"1472084565","%_oembed_6c99da72135176b0f5d6054535088a4f%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/5ECK4O20Fmk?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_6c99da72135176b0f5d6054535088a4f%":"1492854077","%_oembed_bb53d2afc0aba78957851b86ce73f060%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/kKy9gPMC8hA?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_bb53d2afc0aba78957851b86ce73f060%":"1492854077","%_oembed_02fd6ffabf28278a3c65a47d1d1d4cc0%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/videoseries?list=PLG0f76gvWfh-YVSaKDGzq-UpEdIclsUpW\" frameborder=\"0\" gesture=\"media\" allow=\"encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_02fd6ffabf28278a3c65a47d1d1d4cc0%":"1515519433","%_oembed_4b0f64cb2091c3999c8d4b4c41135d5f%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/videoseries?list=PLG0f76gvWfh-YVSaKDGzq-UpEdIclsUpW\" frameborder=\"0\" gesture=\"media\" allow=\"encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_4b0f64cb2091c3999c8d4b4c41135d5f%":"1515519433","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_majors%":"","%_oembed_fd174cce3516de4cca6a9b546f98b04c%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/kKy9gPMC8hA?feature=oembed\" frameborder=\"0\" gesture=\"media\" allow=\"encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_fd174cce3516de4cca6a9b546f98b04c%":"1515546979","%_oembed_b315d368c342ef4fe464807d47197c53%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/AuCHj0ugHMM?feature=oembed\" frameborder=\"0\" gesture=\"media\" allow=\"encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_b315d368c342ef4fe464807d47197c53%":"1515547058","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_oembed_1c2498e7ade157589d29bb7be59449e1%":"<iframe title=\"Music Division - Boston Conservatory at Berklee\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/kKy9gPMC8hA?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_1c2498e7ade157589d29bb7be59449e1%":"1567721192","%_oembed_7ab011592af7bb18a0ba085126aab244%":"<iframe title=\"Boston Conservatory at Berklee - Music Division History\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/AuCHj0ugHMM?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_7ab011592af7bb18a0ba085126aab244%":"1567721192","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_e80894694560e0710c9a3ac081551a08%":"<iframe title=\"Music Division - Boston Conservatory at Berklee\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Ege8VTVQ-jk?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_e80894694560e0710c9a3ac081551a08%":"1602889062","%_oembed_2870c977b08e927f5ea049a5d8f1bde2%":"<iframe title=\"Alara Ensemble - Astor Piazzolla: Four Seasons of Buenos Aires - Oto\u00f1o\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/videoseries?list=PLG0f76gvWfh-YVSaKDGzq-UpEdIclsUpW\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_2870c977b08e927f5ea049a5d8f1bde2%":"1602889062","%_oembed_8e1732806364661435579363b9b8e2c5%":"<iframe title=\"Alara Ensemble - Astor Piazzolla: Four Seasons of Buenos Aires - Oto\u00f1o\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/9_FBGAdlFSE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_8e1732806364661435579363b9b8e2c5%":"1603057220","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_thumbnail_id%":"23516","%_wpb_shortcodes_custom_css_updated%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_3a1ef4ef81ab51564ce18b295bf07028%":"<iframe title=\"Music Division - Boston Conservatory at Berklee\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Ege8VTVQ-jk?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_3a1ef4ef81ab51564ce18b295bf07028%":"1701561131","%_oembed_3e9c7264ad73adf9b372de4e83710c6c%":"<iframe title=\"Alara Ensemble - Astor Piazzolla: Four Seasons of Buenos Aires - Oto\u00f1o\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/9_FBGAdlFSE?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_3e9c7264ad73adf9b372de4e83710c6c%":"1701561131","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_monsterinsights_sitenote_active%":"0","%_wpb_post_custom_layout%":"default","taxonomy=post_tag":"Boston Conservatory, Boston Conservatory at Berklee, College of Music, major in music, majoring in music, music conservatory, music degrees, music education, music major, music school, music schools, music students, School of Music","taxonomy=schools_degrees":"Graduate Majors Offered, Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"Collaborative Piano, Composition &amp; Theory, Conducting, Music Education, Musical Theatre, Pedagogy, Performance - Instrumental, Performance - Vocal","taxonomy=schools_majors":"Composition &amp; Theory, Performance - Instrumental, Performance - Vocal","taxonomy=schools_Region":"Eastern US Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png"},"id":13430,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","name":"Eastern US Music Schools","id":"1","type":"category"}]},{"source":"post","title":"Leeds Conservatoire (UK)","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\">\r\n    <div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Leeds Conservatoire (UK)\" width=\"600\" height=\"338\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/leeds-600x338.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-item-padding-content_20\">\r\n        <div class=\"fc-item-title fc-item-primary-text-color\"><a target=\"_blank\" href=\"https:\/\/majoringinmusic.com\/music-schools\/schools\/leeds-conservatoire\/\" class=\"fc-post-link\">Leeds Conservatoire (UK)<\/a><\/div>\r\n            <div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\r\n                \r\n            <\/div>\r\n        <\/div>\r\n    <\/div>\r\n<\/div>","address":"Leeds College of Music, Leeds, United Kingdom","location":{"lat":"53.797437","lng":"-1.5328890000000683","onclick_action":"marker","redirect_permalink":"https:\/\/majoringinmusic.com\/music-schools\/schools\/leeds-conservatoire\/","zoom":3,"extra_fields":{"post_excerpt":"","post_content":"[vc_row][vc_column][vc_column_text css=\"\"]\r\n<h3><b>Study at Leeds Conservatoire and become part of a dynamic, creative community with great links to industry. <\/b><\/h3>\r\nLeeds Conservatoire is a leader in music education introducing <b>the first Jazz degree in Europe and being the first to offer Popular Music and Music Production in the UK.<\/b> We are the <b>largest Conservatoire in the UK<\/b> and the only one in England with All-Steinway status.\r\n\r\n<b>We offer 3 year Bachelors (Honours) degrees:<\/b>\r\n\r\nMusic Production*\r\n\r\nMusic Business\r\n\r\nElectronic Music Production\r\n\r\nFilm Music\r\n\r\nMusic (Jazz, Classical, Popular or Folk, Roots &amp; Blues)*\r\n\r\nSongwriting\r\n\r\nActing\r\n\r\nMusical Theatre\r\n\r\nActor Musician\r\n\r\nVoice (Performance and Pedagogy)\r\n\r\nTop-Up Musical Theatre Studies (Online, 1 year)\r\n\r\n* These can be combined as a Major and Minor\r\n\r\n<b>We also have a suite of 1 year Masters courses in Music or Performing Arts related fields.<\/b>\r\n\r\n<em><strong>Auditions occur in the UK, NYC, and Chicago<\/strong><\/em>\r\n\r\nOur world-class facilities include <strong>industry-standard equipment and software in all of our\u00a0studios<\/strong>, high-spec rehearsal rooms, top-notch instrument and equipment loan. Our new facilities include two purpose-built dance and drama studios and custom-designed rehearsal spaces for our drama students.<span class=\"Apple-converted-space\">\u00a0<\/span>\r\n\r\nWe are renowned for being a friendly conservatoire with a close-knit community. Our supportive tutors will help you to get the most out of your study, whilst our amazing Student Services team are on hand to offer help and guidance with all aspects of student life \u2013 including careers and health and wellbeing.<a href=\"https:\/\/www.leedsconservatoire.ac.uk\/student-life\/facilities-resources\/\"><b>\r\n<\/b><\/a>\r\n\r\nOften named the best student city in the UK, Leeds is an exciting city with something for everyone. With an amazing food scene, fantastic independent shopping, strong sports and leading cultural institutions in ballet, opera, art and theatre. Leeds has one of the most vibrant music scenes in the UK.\r\n\r\n<b>We offer 12 Scholarships \u00a35000 each to outstanding international applicants.<\/b>\r\n\r\n&nbsp;\r\n<div>\r\n\r\n<hr \/>\r\n\r\n<\/div>\r\n[\/vc_column_text][vc_column_text el_class=\"schools-links\"][acf field='school_links']\r\n\r\n<a class=\"btn-primary\" href=\"#more-information\">Request more information<\/a>[\/vc_column_text][vc_row_inner el_class=\"schools-multimedia\"][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/www.youtube.com\/watch?v=jdGtue6kJBU\" css=\"\"][\/vc_column_inner][vc_column_inner width=\"1\/2\"][vc_video link=\"https:\/\/youtu.be\/DfU2NRGfRh0\"][\/vc_column_inner][\/vc_row_inner][vc_separator border_width=\"10\" css=\".vc_custom_1463693471018{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}\"][vc_gallery type=\"image_grid\" images=\"26382,26385,26383,26384\" img_size=\"600x400\" onclick=\"\" css=\"\"][vc_column_text]\r\n<div id=\"more-information\"><\/div>\r\n[\/vc_column_text][gravityform id=\"29\" title=\"true\" description=\"true\" ajax=\"true\"][ultimate_google_map lat=\"53.797437\" lng=\"-1.5328890000000683\" zoom=\"12\" scrollwheel=\"disable\" marker_icon=\"custom\" icon_img=\"id^14278|url^http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png|caption^null|alt^null|title^markerBlue|description^null\" streetviewcontrol=\"true\" zoomcontrol=\"true\" map_style=\"JTVCJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJsYW5kc2NhcGUlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0E2NSU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycG9pJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBNTElN0QlMkMlN0IlMjJ2aXNpYmlsaXR5JTIyJTNBJTIyc2ltcGxpZmllZCUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5oaWdod2F5JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMnJvYWQuYXJ0ZXJpYWwlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EzMCU3RCUyQyU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvbiUyMiU3RCU1RCU3RCUyQyU3QiUyMmZlYXR1cmVUeXBlJTIyJTNBJTIycm9hZC5sb2NhbCUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTEwMCU3RCUyQyU3QiUyMmxpZ2h0bmVzcyUyMiUzQTQwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTVEJTdEJTJDJTdCJTIyZmVhdHVyZVR5cGUlMjIlM0ElMjJ0cmFuc2l0JTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnNhdHVyYXRpb24lMjIlM0EtMTAwJTdEJTJDJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMnNpbXBsaWZpZWQlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMmFkbWluaXN0cmF0aXZlLnByb3ZpbmNlJTIyJTJDJTIyc3R5bGVycyUyMiUzQSU1QiU3QiUyMnZpc2liaWxpdHklMjIlM0ElMjJvZmYlMjIlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJsYWJlbHMlMjIlMkMlMjJzdHlsZXJzJTIyJTNBJTVCJTdCJTIydmlzaWJpbGl0eSUyMiUzQSUyMm9uJTIyJTdEJTJDJTdCJTIybGlnaHRuZXNzJTIyJTNBLTI1JTdEJTJDJTdCJTIyc2F0dXJhdGlvbiUyMiUzQS0xMDAlN0QlNUQlN0QlMkMlN0IlMjJmZWF0dXJlVHlwZSUyMiUzQSUyMndhdGVyJTIyJTJDJTIyZWxlbWVudFR5cGUlMjIlM0ElMjJnZW9tZXRyeSUyMiUyQyUyMnN0eWxlcnMlMjIlM0ElNUIlN0IlMjJodWUlMjIlM0ElMjIlMjNmZmZmMDAlMjIlN0QlMkMlN0IlMjJsaWdodG5lc3MlMjIlM0EtMjUlN0QlMkMlN0IlMjJzYXR1cmF0aW9uJTIyJTNBLTk3JTdEJTVEJTdEJTVE\"][\/ultimate_google_map][\/vc_column][\/vc_row]","post_title":"Leeds Conservatoire (UK)","post_link":"https:\/\/majoringinmusic.com\/music-schools\/schools\/leeds-conservatoire\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Leeds Conservatoire (UK)\" width=\"600\" height=\"338\" src=\"https:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/05\/leeds-600x338.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"","post_tags":"College of Music, jazz, Leeds Conservatoire, major in music, majoring in music, music business, music education, music industry, music school, music schools, music students, music technology, musical theatre, popular music","%_edit_lock%":"1734115262:4","%_edit_last%":"4","%_wpb_vc_js_status%":"true","%majoring-in-music_layout%":"","%ultimatum_video%":"","%ultimatum_author%":"false","%school_logo%":"21223","%_school_logo%":"field_572acdf03d623","%school_sidebar_photo%":"26381","%_school_sidebar_photo%":"field_572ace183d624","%school_links%":"<ul>\r\n \t<li><a href=\"https:\/\/www.leedsconservatoire.ac.uk\" target=\"_blank\" rel=\"noopener\">Music School Homepage<\/a><\/li>\r\n \t<li><a title=\"Leeds College of Music\" href=\"https:\/\/www.leedsconservatoire.ac.uk\/courses\/undergraduate-courses\/\" target=\"_blank\" rel=\"noopener\">Undergraduate Majors<\/a><\/li>\r\n \t<li><a title=\"Leeds College of Music\" href=\"https:\/\/www.leedsconservatoire.ac.uk\/about-us\/tutors\/\" target=\"_blank\" rel=\"noopener\">Faculty (\"Tutors\" in England)<\/a><\/li>\r\n \t<li><a title=\"Leeds College of Music\" href=\"https:\/\/www.leedsconservatoire.ac.uk\/courses\/undergraduate-study\/how-to-apply\/\" target=\"_blank\" rel=\"noopener\">Application Requirements<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.leedsconservatoire.ac.uk\/courses\/undergraduate-study\/how-to-apply\/\" target=\"_blank\" rel=\"noopener\">How to Apply<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.leedsconservatoire.ac.uk\/courses\/undergraduate-study\/audition-information\/\" target=\"_blank\" rel=\"noopener\">Auditions<\/a><\/li>\r\n \t<li><a title=\"Leeds College of Music\" href=\"https:\/\/www.leedsconservatoire.ac.uk\/courses\/international-applicants\/fees-funding\/tuition-fees-scholarships\/\" target=\"_blank\" rel=\"noopener\">Cost of Attendance<\/a><\/li>\r\n \t<li><a href=\"https:\/\/www.leedsconservatoire.ac.uk\/courses\/international-applicants\/\" target=\"_blank\" rel=\"noopener\">International Applicants<\/a><\/li>\r\n \t<li><a title=\"Leeds College of Music\" href=\"https:\/\/www.leedsconservatoire.ac.uk\/courses\/summer-school\/summer-academy\/\" target=\"_blank\" rel=\"noopener\">Summer Academy<\/a><\/li>\r\n \t<li><a title=\"Leeds College of Music\" href=\"https:\/\/www.leedsconservatoire.ac.uk\/about-us\/graduates\/meet-our-alumni\/graduate-careers\/\" target=\"_blank\" rel=\"noopener\">Alumni Successes<\/a><\/li>\r\n<\/ul>","%_school_links%":"field_572ace3c3d625","%school_multimedia%":"","%_school_multimedia%":"field_572ace643d626","%school_gallery%":"","%_school_gallery%":"field_572ad090d79e3","%_yoast_wpseo_primary_schools_Region%":"350","%scbool_address%":"3 Quarry Hill, Leeds LS2 7PD, United Kingdom","%school_lat%":"53.7974401","%school_long%":"-1.535083","%_wpgmp_location_address%":"Leeds College of Music, Leeds, United Kingdom","%_wpgmp_metabox_latitude%":"53.797437","%_wpgmp_metabox_longitude%":"-1.5328890000000683","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:3:{i:0;s:1:\"1\";i:1;s:1:\"5\";i:2;s:1:\"7\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"4\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%category_sticky_post%":"0","%_thumbnail_id%":"25897","%_oembed_aaad392f473e87cf404c3c3a1d0086c0%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/lYpaIm07e1c?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_aaad392f473e87cf404c3c3a1d0086c0%":"1463689438","%_oembed_89a7ce517482a9474ef14b54f0cc51fd%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/r5ofQCy1WLw?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_89a7ce517482a9474ef14b54f0cc51fd%":"1463689438","%_wp_old_slug%":"leeds-college-music-uk","%_wpb_shortcodes_custom_css%":".vc_custom_1463693471018{padding-top: 5px !important;padding-right: 2% !important;padding-bottom: 15px !important;}","%_yoast_wpseo_metadesc%":"At Leeds Leeds Conservatoire in the U.K, we understand that choosing a place to study overseas can be a challenging decision to make and you will have many questions, so hopefully the following information will help you.","%_yoast_wpseo_focuskw_text_input%":"Leeds College of Music","%_yoast_wpseo_focuskw%":"Leeds Conservatoire","%_yoast_wpseo_linkdex%":"74","%_yoast_wpseo_content_score%":"90","%_oembed_45ea2ea4e4c7a860b53bad6c49218409%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/lYpaIm07e1c?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_45ea2ea4e4c7a860b53bad6c49218409%":"1492839289","%_oembed_1738fce00200d8b4d3e4a3a270d52af0%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/r5ofQCy1WLw?feature=oembed\" frameborder=\"0\" allowfullscreen><\/iframe>","%_oembed_time_1738fce00200d8b4d3e4a3a270d52af0%":"1492839289","%easyindexInvalidate%":"1","%_yoast_wpseo_primary_schools_degrees%":"","%_yoast_wpseo_primary_schools_graduateschools_majors%":"","%_yoast_wpseo_primary_schools_majors%":"","%_oembed_139150975835c3cc941eb975a492dae5%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/videoseries?list=PLuDTpU-RcFapndSa-tRaxcPDC76-IJgij\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_139150975835c3cc941eb975a492dae5%":"1532632001","%_oembed_1aee22721305d59e41fd9715ef43fd36%":"<iframe width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/BNW5xf-B0xc?feature=oembed\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen><\/iframe>","%_oembed_time_1aee22721305d59e41fd9715ef43fd36%":"1532632001","%_oembed_a49b41003bc7f72d734588f8637a4982%":"<iframe title=\"Mamilah - Mosaic Beauty | Crosswire Sessions\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/videoseries?list=PLuDTpU-RcFapndSa-tRaxcPDC76-IJgij\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_a49b41003bc7f72d734588f8637a4982%":"1567724822","%_oembed_5baec2874c49243c869f04613320500c%":"<iframe title=\"Life at Leeds College of Music\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/BNW5xf-B0xc?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_5baec2874c49243c869f04613320500c%":"1567724822","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%facebook-social%":"","%_facebook-social%":"field_5d1d214c97bf9","%twitter-social%":"","%_twitter-social%":"field_5d1d217f97bfa","%instagram-social%":"","%_instagram-social%":"field_5d1d21b597bfb","%youtube-social%":"","%_youtube-social%":"field_5d1d21d597bfc","%_oembed_4d4f6c4a046dc7c70c34f58c95259ab1%":"<iframe title=\"Life at Leeds Conservatoire\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Mj8W_73EbNI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_4d4f6c4a046dc7c70c34f58c95259ab1%":"1596645035","%_oembed_33132a6bc6e6ac89a9092953d6f519d0%":"<iframe title=\"Allora - Karma | Crosswire Sessions\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/-jHlCE_o63M?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe>","%_oembed_time_33132a6bc6e6ac89a9092953d6f519d0%":"1596645035","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wpb_shortcodes_custom_css_updated%":"1","%_oembed_eb0fa7c0548aa4c79ad90089faecbbd4%":"<iframe title=\"Life at Leeds Conservatoire\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/Mj8W_73EbNI?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_eb0fa7c0548aa4c79ad90089faecbbd4%":"1701542769","%_oembed_65f408920053c348b2a708dab68a15e1%":"<iframe title=\"Allora - Karma | Crosswire Sessions\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/-jHlCE_o63M?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_65f408920053c348b2a708dab68a15e1%":"1701542769","%_monsterinsights_sitenote_active%":"0","%_yoast_wpseo_wordproof_timestamp%":"","%_oembed_b9cd1d62d5158d1bd473e5b37b1fb2dc%":"<iframe title=\"International Student Experience at Leeds Conservatoire\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/DfU2NRGfRh0?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_b9cd1d62d5158d1bd473e5b37b1fb2dc%":"1702582304","%_oembed_fc3cde99a518fa931099a6a16304a979%":"<iframe title=\"International Student Experience at Leeds Conservatoire\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/DfU2NRGfRh0?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen><\/iframe>","%_oembed_time_fc3cde99a518fa931099a6a16304a979%":"1702660412","%_wpb_post_custom_layout%":"default","%tiktok-social%":"","%_tiktok-social%":"field_6658b16ac86cc","%_oembed_ae6c7607b40ca1d3b38349c4ce7b3145%":"<iframe title=\"Why Leeds Conservatoire? \/\/ Therese Ulvan - International Alumni\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/jdGtue6kJBU?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>","%_oembed_time_ae6c7607b40ca1d3b38349c4ce7b3145%":"1733167507","taxonomy=post_tag":"College of Music, jazz, Leeds Conservatoire, major in music, majoring in music, music business, music education, music industry, music school, music schools, music students, music technology, musical theatre, popular music","taxonomy=schools_degrees":"Undergraduate Majors Offered","taxonomy=schools_graduateschools_majors":"","taxonomy=schools_majors":"Commercial Music\/ Popular Music\/ Contemporary\/ Songwriting, Ethnomusicology, Music Business, Performance - Instrumental, Performance - Jazz Instrumental, Recording\/ Production\/ Engineering","taxonomy=schools_Region":"International Music Schools"},"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png"},"id":13219,"infowindow_disable":false,"categories":[{"icon":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png","name":"International Music Schools","id":"4","type":"category"}]}],"styles":"[{\"featureType\":\"landscape\",\"stylers\":[{\"saturation\":-100},{\"lightness\":65},{\"visibility\":\"on\"}]},{\"featureType\":\"poi\",\"stylers\":[{\"saturation\":-100},{\"lightness\":51},{\"visibility\":\"simplified\"}]},{\"featureType\":\"road.highway\",\"stylers\":[{\"saturation\":-100},{\"visibility\":\"simplified\"}]},{\"featureType\":\"road.arterial\",\"stylers\":[{\"saturation\":-100},{\"lightness\":30},{\"visibility\":\"on\"}]},{\"featureType\":\"road.local\",\"stylers\":[{\"saturation\":-100},{\"lightness\":40},{\"visibility\":\"on\"}]},{\"featureType\":\"transit\",\"stylers\":[{\"saturation\":-100},{\"visibility\":\"simplified\"}]},{\"featureType\":\"administrative.province\",\"stylers\":[{\"visibility\":\"off\"}]},{\"featureType\":\"water\",\"elementType\":\"labels\",\"stylers\":[{\"visibility\":\"on\"},{\"lightness\":-25},{\"saturation\":-100}]},{\"featureType\":\"water\",\"elementType\":\"geometry\",\"stylers\":[{\"hue\":\"#ffff00\"},{\"lightness\":-25},{\"saturation\":-97}]}]","marker_cluster":{"grid":"12","max_zoom":"19","image_path":"https:\/\/majoringinmusic.com\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/m","icon":"https:\/\/majoringinmusic.com\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/cluster\/1.png","hover_icon":"https:\/\/majoringinmusic.com\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/cluster\/2.png","apply_style":true,"marker_zoom_level":"8"},"map_property":{"map_id":"7","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":{"1":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerGreen.png","3":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerOrange.png","4":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerBlue.png","5":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerYellow.png","6":"http:\/\/majoringinmusic.com\/wp-content\/uploads\/2016\/06\/markerPurpleNew-1.png"}}